Gradland
← GitHub Hot
🔥

GitHub Hot — 13 April 2026

13 April 2026·24 min readGitHubOpen SourceTools

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

1. farzaa/clicky

4,072 stars this week · Swift

Clicky is an open-source macOS AI teaching assistant that floats next to your cursor, watches your screen, and explains what it sees using Claude + voice — think Clippy but actually useful.

Use case

Developers and learners often get stuck context-switching between a tutorial, their editor, and an AI chat window. Clicky collapses that into a single ambient overlay: you're debugging a Supabase RLS policy in Xcode or VS Code, and Clicky literally points at the broken line and talks you through the fix without you leaving the screen or copy-pasting anything.

Why it's trending

The original demo tweet went viral this week because it's the first polished, open-source implementation of a 'screen-aware AI buddy' using ScreenCaptureKit + Claude's vision — it makes the abstract idea of ambient AI assistance feel immediately real and hackable. It also rides the Claude Code wave by using it as the recommended setup tool, which is itself trending.

How to use it

  1. Deploy the Cloudflare Worker proxy first — run cd worker && npm install, then npx wrangler secret put ANTHROPIC_API_KEY (repeat for AssemblyAI and ElevenLabs keys). This keeps your keys out of the Swift binary.,2. Run npx wrangler deploy to push the worker, then copy the worker URL it gives you — you'll paste this into the Xcode project's config.,3. Open the Xcode project, set your worker URL in the config file, then build and run on macOS 14.2+. Grant screen recording and microphone permissions when prompted.,4. To add a custom feature (e.g., a 'explain this code' mode), open the project with Claude Code and describe what you want: 'Add a keyboard shortcut that captures the current screen region and returns a one-paragraph explanation as a floating tooltip.' Claude Code will navigate the Swift codebase and implement it.,5. Fork the repo and swap the ElevenLabs voice model or Claude model version in the worker to experiment with latency vs. quality tradeoffs without touching the Swift layer.

How I could use this

  1. Build a 'blog writing coach' variant of Clicky: a macOS overlay that watches you write in your Next.js MDX editor, detects when you paste a rough paragraph, and whispers suggestions (via ElevenLabs TTS) like 'this intro buries the lede — lead with the problem instead.' Bind it to a hotkey so it only activates on demand, not constantly.
  2. Fork Clicky into a portfolio review tool for job seekers: it watches your screen as you browse a job posting, then automatically compares the visible requirements against your resume (stored as a Supabase vector embedding) and reads aloud which skills you're missing — all without leaving the job board tab. Ship it as a free Mac download to drive traffic to your blog.
  3. Use Clicky's Cloudflare Worker pattern (thin proxy that holds API keys) as the architecture for your blog's AI features: instead of exposing Anthropic keys in Next.js API routes, route all Claude calls through a Cloudflare Worker. This gives you rate limiting, key rotation, and zero cold-start latency for edge inference — and you already have the worker scaffold from Clicky's codebase.

2. alchaincyf/hermes-agent-orange-book

2,274 stars this week · various

A free, comprehensive 17-chapter PDF guide (in English and Chinese) to building real AI agents with Nous Research's open-source Hermes Agent framework, covering its self-improving learning loop and three-layer memory system.

Use case

Developers who want to build production AI agents beyond simple prompt chaining hit a wall with OpenAI Assistants or LangChain — they lack structured memory, self-improvement, and skill persistence. This guide walks through Hermes Agent's architecture concretely: e.g., building a knowledge assistant that remembers past interactions, auto-creates reusable Skills, and evolves its own behavior without manual prompt re-engineering.

Why it's trending

Nous Research dropped Hermes Agent in early 2026 as a direct open-source challenger to Claude Code and OpenClaw, and this is currently one of the only structured English-language deep-dives into it — 2,274 stars in a week signals developers are hungry for practical Hermes documentation that doesn't exist yet in official docs.

How to use it

  1. Download the English PDF directly: curl -L -o hermes-guide.pdf 'https://github.com/alchaincyf/hermes-agent-orange-book/raw/main/Hermes-Agent-The-Complete-Guide-v260407.pdf' and skim Part 2 (§03-06) first to understand the learning loop and memory layers before touching code.,2. Clone the actual Hermes Agent framework: git clone https://github.com/NousResearch/hermes-agent && cd hermes-agent && pip install -e . — the book's §07-08 maps directly to this repo's setup flow.,3. Run your first agent conversation following §09, paying attention to how Skills get auto-generated in ~/.hermes/skills/ after repeated task patterns — this is the self-improvement mechanism.,4. Use §12 (Knowledge Assistant scenario) as your template: wire Hermes to a local markdown directory or Supabase vector store so its episodic memory layer persists between sessions via pgvector.,5. Read §16-17 last — the three-way comparison (Hermes vs Claude Code vs OpenClaw) will clarify which tool to reach for in which situation rather than defaulting to Hermes for everything.

How I could use this

  1. Build a 'Blog Brain' agent on your Next.js blog: connect Hermes to your Supabase posts table via its tool ecosystem, let it index all your past writing into its memory layer, then expose a /api/agent route where readers can ask 'What has Henry written about RAG?' — the agent answers with citations and auto-creates a 'blog search' Skill that improves over time without you touching the prompt.
  2. Create a self-improving cover letter agent for your career tools section: feed Hermes a job description + your resume, let it draft a cover letter, capture the feedback you give it (too formal, missing X), and watch its Skill for 'cover letter tone calibration' evolve across sessions — far more useful than a stateless GPT wrapper because it remembers what worked for you specifically.
  3. Use Hermes' multi-agent orchestration (§15) to automate your content creation pipeline: Agent A monitors your GitHub commits and extracts interesting technical decisions, Agent B drafts a blog post draft in your voice using episodic memory of past posts, Agent C checks it against your style guide Skill — all triggered by a Supabase webhook on new commit events, surfacing drafts in a simple Next.js admin dashboard for your review.

3. yizhiyanhua-ai/fireworks-tech-graph

2,003 stars this week · Python

A Claude Code skill that converts natural language descriptions into production-ready SVG+PNG technical diagrams across 14 diagram types and 7 visual styles — no Figma, no draw.io, no hand-coding SVG.

Use case

Technical writers and engineers constantly waste time manually maintaining architecture diagrams that go stale the moment the system changes. This solves the 'diagram debt' problem: describe your RAG pipeline or multi-agent system in plain English, get a 1920px export-ready PNG in seconds. Concrete example: instead of spending 45 minutes in draw.io laying out a Supabase + pgvector + LLM retrieval flow, you type 'Generate a RAG architecture with Supabase vector store, embedding model, and streaming LLM response, blueprint style' and get a publication-ready diagram.

Why it's trending

Claude Code's skill/plugin ecosystem is exploding right now as developers discover it can go far beyond code generation — this repo is one of the first high-quality domain-specific skills targeting AI/Agent architecture patterns (RAG, Mem0, Tool Call flows) that engineers actually need to diagram daily. It's also hitting at a moment when technical blogging and AI system documentation are in high demand.

How to use it

  1. Install Claude Code and clone the repo: git clone https://github.com/yizhiyanhua-ai/fireworks-tech-graph && cd fireworks-tech-graph
  2. Install the system dependency for PNG export: brew install librsvg (macOS) or apt-get install librsvg2-bin (Linux)
  3. Register the skill with Claude Code by pointing it at the skill manifest in the repo (follow the README's skill registration step — typically claude code skill add ./skill.json)
  4. In a Claude Code session, invoke it naturally: 'Generate a Next.js + Supabase auth flow diagram, Notion Clean style' — the skill classifies the diagram type, generates SVG, then auto-exports a PNG via rsvg-convert
  5. Find your outputs as {name}.svg and {name}.png in the working directory, ready to drop into blog posts or documentation

How I could use this

  1. Auto-generate a fresh architecture diagram for every major blog post: when Henry publishes a post about his Supabase + pgvector setup, trigger the skill to produce a matching 'Blueprint style' architecture PNG that gets embedded in the MDX file — keeping diagrams in sync with the actual post content rather than using stale screenshots.
  2. Build a 'System Design Portfolio' page where each card shows an AI-generated diagram of a project Henry has built (RAG pipeline, auth flow, deployment architecture) — generated on-demand via a Claude Code skill call in the build pipeline, so the diagrams always reflect the current repo structure without manual upkeep.
  3. Add a 'Visualize This' feature to the blog's AI chat assistant: when a reader asks a question like 'how does your embedding pipeline work?', the assistant calls this skill behind the scenes to generate a custom SVG diagram and streams it inline into the chat response — turning abstract explanations into instant visual architecture breakdowns.

4. mattmireles/gemma-tuner-multimodal

1,253 stars this week · Python

Fine-tune Gemma 4/3n on text, images, and audio locally on Apple Silicon using LoRA — no NVIDIA GPU or cloud training budget required.

Use case

Most multimodal fine-tuning workflows require CUDA GPUs (Unsloth, axolotl) or lack audio support entirely (MLX-LM). This repo lets a Mac developer fine-tune Gemma on their own private dataset — e.g., a personal corpus of blog posts + screenshots + voice notes — without uploading sensitive data to a cloud trainer or paying for GPU time. Concrete scenario: Henry wants a Gemma model that understands his specific writing style and can caption diagrams from his posts; he can train that locally on a CSV of his articles and exported images.

Why it's trending

Gemma 4 dropped recently with strong multimodal capabilities, and Apple Silicon (M3/M4) has hit the memory bandwidth sweet spot where LoRA fine-tuning of 4-7B models is genuinely practical. Developers are scrambling for a Mac-native toolchain that isn't locked to CUDA.

How to use it

  1. Clone and install: git clone https://github.com/mattmireles/gemma-tuner-multimodal && cd gemma-tuner-multimodal && pip install -r requirements.txt
  2. Run the wizard CLI to scaffold a config: python tune.py --wizard — it walks you through model size, modality (text/image/audio), and dataset path.
  3. Prepare your CSV: for image+text, columns are image_path and caption; for text-only, prompt and completion. Point the config at your file.
  4. Start training with the live visualizer: python tune.py --config my_config.yaml --visualize then open the printed localhost URL to watch loss curves and attention heatmaps in real time.
  5. Export the LoRA adapter: the output is a standard PEFT-compatible adapter folder you can load with PeftModel.from_pretrained() in any Hugging Face pipeline.

How I could use this

  1. Fine-tune Gemma on Henry's entire blog post archive (exported as a CSV of markdown + featured images) to create a style-matched AI writing assistant that suggests continuations or rewrites drafts in his exact voice — then expose it as a Next.js API route backed by the local adapter via a small FastAPI sidecar.
  2. Train an audio+text LoRA on recordings of Henry narrating his technical walkthroughs, then build a career tool that auto-generates timestamped show notes and LinkedIn summaries from new audio recordings — giving him a private, on-device alternative to Whisper+GPT-4 that's tuned to his domain vocabulary.
  3. Build a 'smart screenshot explainer' feature for the blog: fine-tune on pairs of (code screenshot, explanation text) sourced from his existing posts, deploy the adapter as a serverless function on a cheap VPS, and wire it into a Supabase Edge Function so readers can upload any code screenshot and get an explanation in Henry's teaching style.

5. QLHazyCoder/codex-oauth-automation-extension

1,180 stars this week · JavaScript

A Chrome extension that automates bulk OpenAI OAuth account registration using real email providers and CAPTCHA bypass — essentially a bot for mass-creating ChatGPT accounts.

Use case

This repo should not be used. It automates the creation of hundreds of OpenAI accounts in bulk (150 accounts is the demo claim), which directly violates OpenAI's Terms of Service (Section 3: account sharing, automated signups). The 'CPA callback' references affiliate fraud patterns. The real problem it claims to solve — needing multiple API keys to avoid rate limits — has legitimate solutions like API key rotation with a single paid account or using OpenRouter.

Why it's trending

Trending because OpenAI Codex re-launched with free tier access this week, creating immediate demand for bulk accounts to bypass usage caps. Stars are spiking from people trying to scrape free Codex quota at scale.

How to use it

DO NOT USE THIS. Here is what you should do instead if your actual problem is API rate limits or cost management: 1) Use OpenRouter (openrouter.ai) which aggregates multiple LLM providers under one API key with automatic fallback. 2) Implement proper API key rotation in your Next.js backend using a Supabase table to store multiple legitimate keys and round-robin requests. 3) If you need Codex specifically, sign up for one legitimate account and use the waitlist. 4) For testing/dev environments, use Ollama locally with CodeLlama to avoid API costs entirely. 5) Report this repo to OpenAI's abuse team at abuse@openai.com if you believe it's being used for TOS violations at scale.

How I could use this

  1. AVOID using this — but the underlying Chrome extension architecture (sidebar panel + multi-step automation + config persistence) is actually a clean pattern. Henry could study the sidebar panel implementation (chrome.sidePanel API) to build a LEGITIMATE blog admin Chrome extension that lets him draft posts, trigger Supabase inserts, or preview AI-generated content from any browser tab without leaving the page he's reading.
  2. The multi-provider email polling logic (IMAP for QQ/163/Hotmail via refresh tokens) is technically interesting for a legitimate use case: Henry could build a newsletter signup confirmation tracker for his blog that polls his own inbox for subscriber verification emails and syncs confirmation status back to Supabase — no third-party service needed.
  3. The step-sequencer pattern (single-step execution, auto-run N rounds, stop mid-flow, persist config) is a clean UI pattern for any multi-step AI workflow. Henry could implement this as a visible 'AI pipeline runner' component on his blog that lets readers watch an AI content generation pipeline execute step-by-step — fetch topic → generate outline → expand sections → fact-check → publish draft — as an interactive demo of his AI stack.

6. nashsu/llm_wiki

1,122 stars this week · TypeScript

LLM Wiki is a desktop app that incrementally builds a persistent, interlinked knowledge base from your documents — think Obsidian but the LLM writes and connects the notes for you.

Use case

Traditional RAG systems answer questions by fetching raw chunks at query time, losing structural knowledge between sessions. LLM Wiki solves the 'I have 500 PDFs/articles and no idea what's in them' problem by having an LLM synthesize and maintain actual wiki pages with cross-links, so you end up with a browsable knowledge graph instead of a black-box retrieval system. Concrete example: drop in 3 years of AI research papers and get auto-generated topic pages for 'Attention Mechanisms', 'RLHF', and 'MoE Architectures' with source citations and surprise connection alerts.

Why it's trending

Developers are hitting the ceiling of naive RAG and looking for persistent, structured knowledge representations — this repo ships a working TypeScript/Electron implementation of that pattern with a knowledge graph, Louvain clustering, and LanceDB vector search all wired together. It went viral because it's a rare open-source project that actually builds the 'second brain' product rather than just another chat-with-docs wrapper.

How to use it

  1. Clone and install: git clone https://github.com/nashsu/llm_wiki && cd llm_wiki && npm install,2. Configure your LLM endpoint in settings — supports any OpenAI-compatible API (OpenAI, Ollama, LM Studio). Set OPENAI_API_KEY or point to local endpoint at http://localhost:11434/v1.,3. Run the desktop app: npm run dev — this launches the Electron shell with the Next.js frontend embedded.,4. Import a folder of documents (PDFs, markdown, text files) via the Folder Import feature. The persistent ingest queue processes them serially, generating wiki pages with two-step CoT: analysis pass first, then structured page generation.,5. Explore the knowledge graph UI — use Graph Insights to find unexpected connections between topics, then trigger Deep Research on any knowledge gap to auto-pull web sources and ingest them back into the wiki.

How I could use this

  1. Feed all of Henry's published blog posts into LLM Wiki to auto-generate a 'topics index' page — then expose that generated wiki as a public /knowledge route in his Next.js blog, giving readers a structured map of his thinking over time with cross-linked concept pages.
  2. Drop in his target company's engineering blog posts, job descriptions, and his own resume/projects into LLM Wiki — let it build a knowledge graph, then query the graph to find explicit skill gaps and surprising overlaps between his experience and the company's tech stack to sharpen cover letters.
  3. Fork the two-step CoT ingest pipeline (TypeScript) and adapt it as a Supabase Edge Function that runs on new blog post saves — instead of a desktop app, it builds a server-side wiki in Supabase (pgvector for embeddings, JSONB for wiki page content) that powers an 'explore related ideas' sidebar widget on each blog post.

7. AgriciDaniel/claude-obsidian

976 stars this week · Shell · ai claude-code claude-code-skill knowledge-management

A Claude Code plugin that auto-builds and maintains a structured Obsidian wiki from any source you drop into it, creating a self-compounding knowledge base with zero manual filing.

Use case

Developers and researchers drown in bookmarks, articles, and notes that never get revisited because filing is friction. This solves that by having Claude automatically extract entities, cross-reference concepts, and maintain wiki pages — so if you drop in 10 papers on RAG architecture, you get a live, queryable knowledge graph, not a graveyard of PDFs. Concretely: paste a blog post URL, run /wiki, and Claude creates or updates linked Obsidian pages for every concept mentioned, citing sources.

Why it's trending

Andrej Karpathy published his LLM Wiki pattern recently, which went viral in AI/dev circles, and this repo is the most polished implementation of that pattern using Claude Code's new plugin/skills system — two trending things colliding at once.

How to use it

  1. Install Claude Code CLI and clone the repo: git clone https://github.com/AgriciDaniel/claude-obsidian && cd claude-obsidian,2. Open the vault folder in Obsidian so you have the graph view ready, then point Claude Code at the project root which contains the CLAUDE.md skill definitions.,3. Run /wiki <url-or-paste-content> in Claude Code to ingest a source — Claude extracts entities, creates/updates markdown pages in wiki/, and updates the index automatically.,4. Ask questions with /wiki query: 'how does RAG differ from fine-tuning?' — Claude scans the hot cache and index, drills into relevant pages, and answers citing specific wiki files (not training data).,5. Periodically run /wiki lint to find orphaned pages, dead links, and stale cross-references — Claude cleans the graph without you touching a file.

How I could use this

  1. Feed every blog post Henry publishes into the wiki via /wiki, then expose a '/related-posts' API route in Next.js that queries the Obsidian index files to surface semantically related content — a self-updating 'you might also like' powered by his own knowledge graph, not embeddings you have to maintain.
  2. Build a 'job research vault' workflow: drop in company engineering blogs, job descriptions, and interview prep articles, then use /autoresearch before each application to synthesize a company-specific brief. The hot cache carries context across sessions so Henry doesn't re-read the same docs for follow-up interviews.
  3. Create a 'post drafting assistant' by wiring the Obsidian vault as context for a Supabase Edge Function — when Henry starts a new draft in his blog CMS, the function reads the wiki index and injects relevant linked concepts as a structured outline scaffold, so posts are grounded in his existing knowledge base rather than starting from a blank page.

8. phuryn/claude-usage

906 stars this week · Python · claude-code

A zero-dependency local dashboard that parses Claude Code's raw JSONL logs to give you actual token usage, cost breakdowns, and session history that Anthropic's own UI doesn't expose.

Use case

Claude Code writes detailed JSONL logs locally but buries that data with no native visibility — so you're flying blind on costs and usage patterns. If you're on a Max plan burning through tokens across multiple projects, this lets you see exactly which sessions and models cost the most, so you can decide whether to switch models mid-project or restructure your prompting strategy before hitting your limit.

Why it's trending

Claude Code usage has exploded this month as developers adopt it as a primary coding assistant, but Anthropic still only shows Pro/Max subscribers a basic progress bar — leaving API users and power users completely in the dark on costs. This repo fills that visibility gap with zero setup friction.

How to use it

  1. Clone and run — no pip, no venv: git clone https://github.com/phuryn/claude-usage && cd claude-usage && python3 cli.py dashboard
  2. It auto-discovers your ~/.claude/ JSONL logs and populates a local SQLite DB at ~/.claude/usage.db
  3. Open the browser dashboard (served locally) to see cost breakdowns by session, model, and project
  4. Use python3 cli.py today in terminal for a quick daily summary before starting a heavy coding session
  5. Query the SQLite DB directly for custom analysis: sqlite3 ~/.claude/usage.db 'SELECT project, SUM(cost_usd) FROM sessions GROUP BY project ORDER BY 2 DESC'

How I could use this

  1. Build a 'AI Writing Cost Transparency' widget for your blog that publicly displays how many Claude tokens it cost to generate or edit each post — scrape your usage.db after each blog session, tag costs per post in Supabase, and render it as a small badge like '~$0.12 of AI used' on each article. Differentiates your blog and builds trust with readers about AI-assisted content.
  2. Create a personal AI dev-cost tracker dashboard in your Next.js portfolio — pull from the SQLite DB via a Python API endpoint or scheduled export to Supabase, then visualize weekly Claude spend alongside GitHub commit activity. Lets you correlate 'expensive AI sessions' with actual shipped features, which makes a compelling story in job interviews about disciplined AI tool usage.
  3. Wire this into your blog's draft workflow: after each Claude Code session where you scaffold a new blog feature or AI tool, auto-log the session cost to a Supabase table and trigger a Slack/Discord notification summarizing 'Feature X cost $Y in Claude tokens, Z total input tokens.' Over time this gives you a personal cost-per-feature benchmark that helps you estimate AI tool costs for freelance or consulting projects.

9. momenbasel/PureMac

850 stars this week · Swift · cache-cleaner cleanmymac cleanup disk-cleaner

PureMac is a free, open-source SwiftUI macOS cleaner that replaces CleanMyMac with zero telemetry, scheduled auto-cleaning, and full source auditability.

Use case

Developers running heavy Next.js/TypeScript builds, Xcode projects, and Homebrew installs accumulate gigabytes of derived data, npm caches, and simulator runtimes that silently eat disk space. PureMac lets you schedule automated cleanup of exactly these targets without handing usage data to a $40/year SaaS — useful when you're demoing a portfolio site on a MacBook with a nearly full drive.

Why it's trending

CleanMyMac X recently moved to a subscription-only model with more aggressive telemetry disclosures, driving developers to look for privacy-respecting alternatives — PureMac landed at exactly the right moment. The MIT license and auditable Swift source also resonate with the current OSS-trust zeitgeist post-xz/backdoor concerns.

How to use it

  1. Download the latest .dmg from the GitHub releases page or build from source: git clone https://github.com/momenbasel/PureMac && open PureMac.xcodeproj.
  2. Build and run with Xcode 15+ targeting macOS 13.0+, or just drag the pre-built .app to /Applications.
  3. On first launch, grant disk access via System Settings → Privacy & Security → Full Disk Access → add PureMac.
  4. Select cleanup targets (Xcode Derived Data, Homebrew cache, system logs, trash) and click Scan to preview reclaimed space before committing.
  5. Enable scheduled auto-cleaning under Preferences → Schedule to run weekly cleanups silently in the background — no further interaction needed.

How I could use this

  1. Write a blog post titled 'Auditing an Open-Source macOS App: What PureMac's SwiftUI Source Teaches You About Privacy-First Design' — walk through the codebase showing how it avoids network calls, compare the architecture to how you'd structure a privacy-first Next.js app with no client-side analytics, and use it as a hook to discuss your own blog's zero-telemetry stance.
  2. Build a companion CLI script for your dev workflow: since PureMac targets Xcode/Homebrew caches, write a small shell script (triggered via a GitHub Actions self-hosted runner or a local cron job) that calls the same cache paths PureMac exposes in its source, then posts a weekly 'disk health' Slack/Discord notification — useful to show in a portfolio as 'DevOps tooling' experience.
  3. Use PureMac's scheduled cleaning concept as inspiration for an AI-powered 'blog hygiene' feature: build a Supabase Edge Function that runs weekly, uses an LLM to scan your published posts for outdated npm package references, deprecated Next.js APIs, or dead outbound links, then creates a Supabase row flagging each post for review — framing it as 'PureMac for your content pipeline' makes a compelling demo and blog post.

10. joeynyc/hermes-hudui

826 stars this week · Python

A browser-based dashboard that visualizes the internal state, memory, costs, and behavior of a persistent Hermes AI agent in real-time via WebSocket.

Use case

When you're running a long-lived AI agent that accumulates memory, runs cron jobs, and executes multi-session tasks, you lose visibility into what it actually knows and how much it's costing you. Hermes HUD solves this by exposing 13 tabs of agent introspection — identity, memory graph, skill inventory, token costs per model, correction history — so you can debug 'why did my agent forget X' or 'why did my AWS bill spike' without grepping log files.

Why it's trending

Persistent AI agents are having a moment right now as developers move beyond single-shot LLM calls toward agents that maintain state across sessions, and observability tooling for those agents is still nearly nonexistent. The jump from TUI-only to a full browser UI with WebSocket updates makes this accessible to teams, not just solo terminal users.

How to use it

  1. Install and run Hermes agent first so ~/.hermes/ is populated with real data (repo: github.com/nousresearch/hermes-agent). 2. Clone and install: git clone https://github.com/joeynyc/hermes-hudui.git && cd hermes-hudui && ./install.sh. 3. Start the dashboard: source venv/bin/activate && hermes-hudui then open http://localhost:3001. 4. Use number keys 1–9 to navigate tabs (Memory, Skills, Sessions, Costs, Cron, etc.) and t to switch themes. 5. Hit Ctrl+K for the command palette to run agent commands or trigger chat directly from the dashboard.

How I could use this

  1. Build a lightweight read-only version of this concept for Henry's blog: a public '/agent-status' page that pulls from a Supabase table updated by his background AI writing assistant — showing which posts it's currently drafting, last run time, token spend this month, and a memory log of topics it's been asked to avoid or emphasize. Totally unique 'living blog' branding.
  2. Adapt the per-model token cost tracking tab into a personal AI spend tracker for his career tools project — log every OpenAI/Anthropic API call with model, prompt tokens, completion tokens, and cost to a Supabase table, then surface a Next.js dashboard showing spend-per-feature (resume matcher vs. cover letter vs. blog AI) so he can make data-driven decisions about which features to deprecate or optimize.
  3. Use the agent memory and corrections tabs as inspiration for a 'prompt correction history' feature in his blog's AI writing assistant — every time he edits an AI-generated paragraph, store the before/after diff in Supabase with an embedding of the correction, then feed that corrections vector store back into future generations as few-shot examples so the agent learns his editing style over time.
← All issuesGo build something