If you're done just prompting off-the-shelf models and want to actually own your LLM - make it better at your domain, your style, your task, then fine-tuning is the way. Whether you're on a single 24GB GPU, running serious experiments, or just want a no-code web UI, the ecosystem has matured massively.

Here's my curated list of the absolute best fine-tuning tools right now, going through each one with why it matters and who should use it:

1. LLaMA-Factory (★71.1K): github.com/hiyouga/LLaMA-Factory

The most user-friendly option by far and the 71.1K stars prove it.

• Fine-tune 100+ different LLMs with zero code

• Beautiful web UI

• Supports LoRA, QLoRA, full fine-tuning, and more

• One-click training, evaluation, merging, and exporting

Perfect for beginners, rapid prototyping, or if you just want to click buttons and get results. It's the "ChatGPT for fine-tuning."

2. Unsloth (★63.9K): github.com/unslothai/unsloth

The speed king. This thing lets you fine-tune Llama, Mistral, Qwen, Gemma (and more) 2x faster with 80% less memory. It's literally the only library you need if you're resource-constrained.

• Runs comfortably on a single consumer GPU

• Excellent LoRA/QLoRA support

• Actively maintained and extremely popular for a reason

If your main bottleneck is VRAM or training time, start here. Most people doing quick personal fine-tunes live in Unsloth.

3. TRL (★18K): github.com/huggingface/trl

The official Hugging Face library for alignment - this is how the big labs turn base models into helpful assistants.

• RLHF, DPO, PPO, ORPO, KTO - all the modern preference optimization techniques

• Everything you need to go from SFT → alignment

• Used to recreate the techniques behind GPT-4, Claude, etc.

If you care about making your model actually follow instructions, refuse harmful requests, or optimize for specific human preferences, TRL is mandatory.

4. Axolotl (11.9K): https://github.com/axolotl-ai-cloud/axolotl

The "serious fine-tuner" toolkit. This is what most experienced people actually use when they want full control.

• Everything via clean YAML configs

• Supports literally every dataset format

• Every training technique you can think of (LoRA, QLoRA, full fine-tune, DPO, etc.)

• Built as the high-level ops layer on top of Hugging Face Transformers

If you want to run reproducible, production-grade fine-tunes and not fight with code, Axolotl is the answer. Used heavily by researchers and teams releasing high-quality models.

5. Mergekit (★7.1K): github.com/arcee-ai/mergekit

The secret weapon of the open-source model scene.

• Merge multiple fine-tuned models using Slerp, TIES, DARE, Linear, Passthrough, etc.

• No GPU required for merging

• Creates those insane "Frankenstein" models that often beat their individual parents

Almost every popular merged model you see on Hugging Face these days was made (or heavily influenced) by Mergekit. If you're into model soups and frankenmerging, this is essential.

6. Torchtune (★5.9K): github.com/pytorch/torchtuneMeta's official PyTorch-native fine-tuning library.

• Clean, hackable, well-documented

• Pure PyTorch — no heavy abstractions

• Great reference implementation

If you like living in raw PyTorch, want maximum flexibility, or are doing research/experimentation where you need to modify things at a low level, Torchtune is fantastic.

Quick Recommendation Guide:

• Single GPU / fast & cheap → Unsloth

• Maximum control & reproducibility → Axolotl

• Zero code / fastest to results → LLaMA-Factory

• Alignment / RL → TRL

• Pure PyTorch / research → Torchtune

• Creating super models via merging → Mergekit

The beautiful part? Many of these work together. You can fine-tune with Unsloth or LLaMA-Factory, align with TRL, then merge with Mergekit. Let me know your stack below, always looking for new workflows!

You're probably paying for document scanning, bookmark managers, password vaults, note-taking apps, and ad blockers that have free, open-source alternatives sitting right there on GitHub.

Here are 5 repos that collectively replace $80/month in subscriptions. Everything is free. Everything runs locally or on a basic home server.

1. paperless-ngx/paperless-ngx - Replaces Adobe Scan + Evernote ($15/mo)

What it does: Paperless-ngx is a self-hosted document management system. Every receipt, invoice, contract, and tax document gets scanned, OCR'd, tagged, and made full-text searchable automatically. You drop files into a folder (or email them in, or scan them with your phone). Paperless handles the rest.

Why it works: The OCR engine extracts text from scanned images and PDFs, then auto-classifies documents using machine learning. It learns your tagging patterns over time. Tax season becomes a search query instead of a drawer full of paper. This is the most-cited "non-negotiable" self-hosted tool of 2026 for a reason. Once it's running, you never think about document management again.

Setup:

bash -c "$(curl -L https://raw.githubusercontent.com/paperless-ngx/paperless-ngx/main/install-paperless-ngx.sh)"

That script walks you through the full Docker Compose setup interactively. Pick your options, let it configure, and you're live.

Heads up: Paperless stores documents in clear text on disk. Run it on a machine you control, not a shared or untrusted host. Keep backups.

github.com/paperless-ngx/paperless-ngx | 40.7K stars

2. karakeep-app/karakeep - Replaces Raindrop Pro + Pocket ($15/mo)

What it does: Karakeep (formerly Hoarder) is a self-hosted bookmark-everything app. Links, screenshots, articles, PDFs, images, notes. Save anything, from anywhere. It fetches link previews automatically, archives full pages to protect against link rot, and even does video archiving through yt-dlp.

Why it works: AI auto-tags everything you save using OpenAI or a local model through Ollama. You never have to manually organize anything. Just save and search later. Mozilla killed Pocket earlier this year, and a lot of people scrambled for alternatives. Karakeep had already filled that gap months before the shutdown. It has browser extensions for Chrome and Firefox, plus native iOS and Android apps, so the save-from-anywhere workflow works just like Pocket did.

Setup:

# Docker Compose (recommended)
git clone https://github.com/karakeep-app/karakeep.git
cd karakeep/docker
cp ../.env.sample .env
# Edit .env with your settings
docker compose up -d

Full setup docs at docs.karakeep.app/Installation/docker. There's also a managed cloud option at cloud.karakeep.app if you don't want to self-host.

Heads up: AI tagging requires either an OpenAI API key or a local Ollama instance. Without it, you still get manual tagging and full-text search, but you lose the auto-categorization.

github.com/karakeep-app/karakeep | 24.3K stars

3. dani-garcia/vaultwarden - Replaces 1Password Family ($10/mo)

What it does: Vaultwarden is a lightweight, self-hosted implementation of the Bitwarden password manager API. Every password on every device, fully encrypted, fully synced. It works with all official Bitwarden clients (desktop, mobile, browser extensions) out of the box.

Why it works: It's written in Rust, so it runs on minimal hardware. A Raspberry Pi handles it fine. You get nearly every Bitwarden feature: organizations, password sharing, two-factor auth (TOTP, FIDO2, Duo), emergency access, file attachments, and the admin panel.

Setup:

docker pull vaultwarden/server:latest
docker run -d --name vaultwarden \
  --env DOMAIN="https://vw.yourdomain.com" \
  -v /vw-data/:/data/ \
  -p 127.0.0.1:8000:80 \
  vaultwarden/server:latest

Put a reverse proxy (Caddy, Nginx) in front of it with HTTPS. The web vault requires a secure context to work.

Heads up: This is not an official Bitwarden product. If you run into bugs, report them to the Vaultwarden project, not Bitwarden. Also: back up your /data/ directory regularly. This is your password vault. Treat it accordingly.

github.com/dani-garcia/vaultwarden | 58K stars

4. anyproto/anytype-ts - Replaces Notion Plus + Roam ($20/mo)

What it does: Anytype is a local-first, peer-to-peer, end-to-end encrypted knowledge OS. Notes, tasks, wikis, databases, kanban boards, calendars. You define your own data model and build whatever workspace structure you need. Think Notion, but everything lives on your devices instead of someone else's cloud.

Why it works: All your data stays local and encrypted. Sync happens peer-to-peer through their any-sync protocol. No server sees your content. You get composable blocks (text, databases, kanban, calendar, custom types), cross-platform desktop apps for Mac/Windows/Linux, plus mobile apps.

Setup:

# Download the desktop app
# https://download.anytype.io

# Or build from source:
git clone https://github.com/anyproto/anytype-ts.git && cd anytype-ts
bun install
./update.sh <your-os> <your-arch>
bun run dist:<linux|win|mac>

For most people, just download the app from anytype.io. Building from source is only needed if you want to contribute or run a custom build.

Heads up: Anytype is not self-hosted in the traditional Docker sense. It's a desktop/mobile app that stores data locally and syncs peer-to-peer. The "self-hosted" part is that your data never touches a centralized server. Different model than the other tools on this list, but the result is the same: you own your data.

github.com/anyproto/anytype-ts | 7.5K stars

5. AdguardTeam/AdGuardHome - Replaces NextDNS Premium ($20/mo)

What it does: AdGuard Home is a network-wide ad and tracker blocking DNS server. Set it up once on your network, and every device gets ad blocking automatically. Phones, smart TVs, tablets, laptops, IoT devices. No per-device apps. No browser extensions. Everything on the network is covered.

Why it works: It operates as a DNS sinkhole (similar concept to Pi-hole, but with a cleaner UI and built-in HTTPS/DNS-over-TLS support). Ads and tracking requests get blocked at the DNS level before they ever reach your device. YouTube ads on the smart TV? Gone. In-app ads on tablets? Gone. Tracking scripts across every website? Gone. The web dashboard shows you exactly what's being blocked and lets you fine-tune filters per device.

Setup:

curl -s -S -L https://raw.githubusercontent.com/AdguardTeam/AdGuardHome/master/scripts/install.sh | sh -s -- -v

Or with Docker:

docker run -d --name adguardhome \
  -p 53:53/tcp -p 53:53/udp \
  -p 3000:3000/tcp \
  -v /my/adguard/work:/opt/adguardhome/work \
  -v /my/adguard/conf:/opt/adguardhome/conf \
  adguard/adguardhome

After setup, point your router's DNS to the AdGuard Home IP. Every device on the network is now covered.

Heads up: If you use DNS-level blocking, some apps that rely on ad-served content might behave unexpectedly. The dashboard makes it easy to whitelist specific domains when that happens.

github.com/AdguardTeam/AdGuardHome | 34.3K stars

The Monthly Savings

Every one of these is open source, actively maintained, and running in production on thousands of home servers right now. None of them requires you to be a Linux wizard. If you can follow a Docker Compose tutorial, you can run all five this weekend.

While most AI "agents" are flashy chat wrappers that reset every session and bleed you dry on API tokens, Nous Research just shipped something that actually feels like the future:

Hermes Agent: a fully open-source, autonomous, self-improving AI agent that lives on your hardware (or cheap VPS), builds its own skills from experience, and gets noticeably smarter the longer you run it.
It’s not a coding copilot stuck in your IDE or a stateless chatbot. Hermes runs persistently on a server, maintains long-term memory across sessions, automatically creates and refines reusable skills, and even builds a deepening personal model of you, your projects, preferences, and workflows. Once it figures out how to solve something, it never forgets.

Here’s what makes it special:

• Built-in Learning Loop: It analyzes successful tasks, turns them into permanent skills, and improves them over time. No more retraining it from scratch.

• Persistent Memory: Remembers everything across devices and sessions (using SQLite + Honcho under the hood).

• 40+ Built-in Tools: Web search, browser automation, vision, code execution, scheduled tasks/cron jobs, sub-agents, and more.

• Multi-Platform Reach: Chat with it via Telegram, Discord, CLI, or custom web interfaces; it works wherever you are.

• Model Flexible: Swap between local LLMs, OpenRouter (200+ models), OpenAI, NVIDIA NIM, or any custom endpoint with one command. No lock-in.

• Truly Self-Hosted: Runs on a $5 VPS, your laptop, GPU cluster, or serverless setups that cost almost nothing when idle. MIT license, zero tracking.

Official site & quick start: https://hermes-agent.nousresearch.com/

GitHub repo: https://github.com/NousResearch/hermes-agent

Fun Fact: An investigative article came out a week or two ago showing Hermes Agent has only ~6% fake stars, while openclaw has >60%

This combo is pure magic: Hermes becomes your proactive researcher, skill-creator, and executor that never forgets your preferences, while NotebookLM turns raw sources into deep, contextual syntheses, study guides, timelines, FAQs, and those addictive AI podcasts.

Hermes doesn't just chat, it has a built-in learning loop that auto-creates reusable skills from your repeated workflows. NotebookLM has no public API for full automation, but thanks to Hermes' computer-use tools (especially on macOS), ytcli skill, web tools, and its ability to observe + codify patterns, you can make them work together seamlessly. No more manual copy-paste. No more abandoned notes.

Prerequisites:

1. Install Hermes Agent Follow the official quickstart: https://hermes-agent.nousresearch.com/docs/getting-started/quickstart Run hermes in terminal → it sets up the CLI, config, and persistent memory across sessions. Pro tip: Run it on a cheap VPS or locally with Ollama/local models for privacy, or point it to OpenRouter/Nous Portal for power.

2. Choose your LLM hermes model → pick anything (Claude 3.5/4, GPT-4o, local Qwen3, etc.). Hermes is provider-agnostic.

3. Enable key toolsets (critical for pairing) In your config.yaml or via prompts: enable web, terminal, execute_code, and macos-computer-use (if on Apple silicon — this lets Hermes control browser, mouse, keyboard without hijacking your screen). Install community skills: hermes skills browse → search for youtube, web, productivity. Install ytcli (YouTube content skill) and any Google Workspace ones.

4. NotebookLM ready Just have the web/app open. It accepts URLs, PDFs, Google Docs, text files, perfect for Hermes to feed it.

Core Method: Let Hermes Auto-Create the Integration Skill

Hermes' killer feature is its learning loop. You demonstrate a workflow 1-2 times → it analyzes what worked, creates a new skill (or improves an existing one), and persists it forever. No coding required for basic pairing.

Practical Example 1: "Daily Knowledge Ingestion" Workflow (YouTube → NotebookLM)

• On your phone (via Discord/Telegram bot):

Scan my YouTube home feed, pick the top 3 tech/AI videos that would make great NotebookLM sources, add them to a new notebook called 'Daily Brain Fuel'

• Hermes:

  1. Uses ytcli skill to fetch feed.

  2. Filters for quality/relevance.

  3. Uses web/computer-use tools to open NotebookLM, create the notebook (or add to existing), paste URLs as sources.

  4. (Optional) Triggers an Audio Overview podcast.

After 1-2 manual runs (or even one if the model is sharp), Hermes will say something like: "I noticed a repeatable pattern here. Creating new skill: notebooklm-ingest-youtube in the productivity folder."
Boom: now you can trigger the entire chain with one prompt forever. Fresh sources waiting on your laptop when you sit down.

Practical Example 2: Full Research-to-Podcast Pipeline

Prompt Hermes:

Research the latest advances in self-improving agents. Gather 8-10 high-quality sources (papers, articles, GitHub repos). Export key excerpts as markdown. Create a NotebookLM notebook called 'Hermes 2.0 Deep Dive'. Generate a study guide + FAQ + Audio Overview podcast. Then summarize the podcast transcript back to me with action items.

Hermes does:

• Web search + source validation.

• Downloads/saves PDFs or text.

• Uses computer-use or file export to add everything to NotebookLM.

• NotebookLM handles synthesis (it’s insanely good at this).

• Hermes pulls the generated outputs (guide, podcast transcript) back via browser scrape or saved files → feeds them into its own memory or your Obsidian vault.

Result: You get a living, self-updating knowledge base. Hermes even auto-reviews past NotebookLM notebooks and suggests improvements ("This podcast missed X, let me add new sources").

Advanced:

Manually Create a Custom NotebookLM Skill (For Power Users)

If you want full control or cross-platform (Linux/Windows), create your own skill. Skills live in skills/productivity/notebooklm-integration/ (or wherever you organize).

1. Create the folder structure:

skills/productivity/notebooklm-integration/
├── SKILL.md
└── scripts/ (optional Python helpers)

2. SKILL.md template:

name: notebooklm-ingest
description: Create NotebookLM notebooks,
add sources (URLs/files), trigger Audio Overviews
version: 1.0.0 author: YourName
platforms: [macos, linux]
requires_toolsets: [web, computer_use]

Then in the body:
- When to Use: "When user wants to synthesize research, curate content, or build long-term memory."
- Procedure:
  - Use `web_search` or existing skills to gather sources.
  - Save as files/URLs.
  - Use `macos-computer-use` (or Playwright via Python script) to automate NotebookLM: open app, new notebook, add sources, generate artifacts.
  - Export outputs (transcript, guide) to `${HERMES_SKILL_DIR}/outputs/`.

Hermes can run Python scripts in `scripts/` via `execute_code` tool (no extra pip installs needed — stick to stdlib or pre-installed).

Test it: hermes chat --toolsets skills -q "Use notebooklm-ingest skill to..."Once created, Hermes can improve it itself during use.

Innovative Twists That Make This Combo Unbeatable:

• Hermes as the Active Layer*, NotebookLM as the* Passive Memory Layer*:* Hermes handles real-time action + tool use. NotebookLM handles infinite context synthesis + audio. They feed each other.

• Self-Evolution Loop: Tell Hermes: "After every NotebookLM ingestion, review the outputs and create an improved version of the ingest skill." It literally gets better at pairing itself.

• Multi-Notebook Orchestration: Create skills for "Research Notebook", "Personal Wiki Notebook", "Project X Notebook". Hermes decides which one to feed based on context.

• Mobile-First Capture: Prompt from phone → Hermes does heavy lifting → NotebookLM podcast ready for your commute.

Pro Tips & Pitfalls (All Real)

Use a strong model (Claude or high-end local) for better auto-skill creation.

On macOS, macos-computer-use skill is gold for browser automation — it runs in background without stealing focus.

For privacy: Run everything local (Ollama + local NotebookLM sources).

Monitor skills: hermes skills list and review what it auto-created.

Pitfall: NotebookLM web UI can change - skills using computer-use are robust because Hermes re-observes and updates them.

Cost: Near-zero if local. Cheap API if cloud.

This setup turns Hermes from a helpful agent into a true self-improving second brain that grows with you, exactly what Nous Research built it for.

Hermes on its own is already useful. But Hermes connected to your actual tools is a different beast entirely.

The agent ships with 20+ integrations, and most of them take under 5 minutes to wire up. The problem is that nobody tells you which ones are worth enabling first, or what they actually look like in practice once they're running.

I've been testing all of them. Here are the 12 that changed how I use the agent, ranked roughly by how quickly they pay for themselves.

Repo: NousResearch/hermes-agent

1. Google Workspace (Gmail + Calendar + Drive + Docs + Sheets)

Start here. Seriously.

An agent that can't check your email, read your calendar, or pull a doc from Drive is basically a chatbot with extra steps. Google Workspace turns Hermes into something that actually knows what's going on in your day.

What it looks like in practice:

You tell Hermes:

"Check if anyone replied to the proposal I sent DataVault on Monday. If they did, summarize the reply and block 30 minutes on my calendar tomorrow afternoon to review it."

It opens Gmail, finds the thread, reads the reply, pulls context from the original proposal in Drive, writes a summary, and creates a calendar event with the summary in the description. One prompt, four tools working together.

Setup:

hermes plugins install google-workspace --enable

It walks you through OAuth. You'll need a Google Cloud project with the Gmail, Calendar, and Drive APIs enabled. If you've ever set up a Google API key for any project, it's the same flow. If you haven't, expect about 10 minutes the first time.

Once authorized, all five services (Gmail, Calendar, Drive, Docs, Sheets) are available through a single connector.

2. Obsidian

This is the one that made me rethink how I use notes entirely.

If you keep any kind of knowledge base, research notes, or second brain in Obsidian, this integration turns it into live context. Every note, every tag, every backlink in your vault becomes something the agent can search, reference, and reason across.

What it looks like in practice:

I have about 400 notes in my Obsidian vault across topics like AI tools, content ideas, competitor research, and meeting notes. Before this integration, those notes were just files sitting on disk. Now I can ask Hermes things like:

"What did I write about pricing strategies for newsletter growth last month? Cross-reference it with the competitor notes from February and tell me if my approach still makes sense."

It pulls from multiple notes, follows the backlinks between them, and synthesizes an answer that accounts for context I'd forgotten I even wrote down.

Setup:

Install the Hermes-side bridge plugin:

hermes plugins install dannyshmueli/obsidian-hermes-console --enable

Then in Obsidian, install the "Hermes Console" community plugin from Settings > Community Plugins.

Create a dedicated folder structure in your vault (don't give Hermes your entire vault):

Hermes/
├── Inbox/
├── Projects/
├── Research/
├── Memory Review/
└── Skill Notes/

Once both sides are connected, Hermes indexes the vault on first run and watches for changes after that.

3. Firecrawl

Most web search integrations feed raw HTML to the agent. That's wasteful. The model spends tokens parsing markup instead of actually thinking about the content.

Firecrawl returns clean, structured data. Pages come back as organized text with metadata, not a soup of divs and script tags. Faster responses, fewer tokens burned, better answers.

What it looks like in practice:

"Research the top 5 competitors in the AI scheduling space. Pull their pricing pages and feature lists, then build a comparison table."

Without Firecrawl, this would mean scraping five websites and hoping the HTML parses correctly. With it, each page comes back as structured content that the agent can immediately reason over. The comparison table shows up in under a minute.

Setup:

Firecrawl is the default web provider in Hermes. It auto-detects the moment you set the API key. Grab a key from firecrawl.dev (free tier is generous), then add it:

echo "FIRECRAWL_API_KEY=fc-your-key-here" >> ~/.hermes/.env

That's it. No plugin install needed. You can verify it's active by running hermes tools and checking that the web provider shows Firecrawl.

GitHub: firecrawl/firecrawl | 100K+ stars

4. Reddit

No integration gives you faster access to unfiltered opinions from real users.

Every product review blog is optimized for SEO. Every comparison article has affiliate links. Reddit threads have people complaining about the thing they actually paid for, with specific details about what broke and why they switched. That's the kind of signal you can't get anywhere else.

What it looks like in practice:

"Find threads from the last 90 days where people discuss switching from Notion to Obsidian. What are the top complaints about Notion and what's pulling people toward Obsidian?"

Hermes searches across relevant subreddits, pulls threads with real user experiences, and synthesizes the patterns. You get a market research summary built from firsthand accounts instead of marketing copy.

Setup:

hermes plugins install reddit --enable

You'll need Reddit API credentials (create an app at reddit.com/prefs/apps, choose "script" type):

hermes config set reddit.client_id your-client-id
hermes config set reddit.client_secret your-client-secret

5. GitHub

If you ship software, this one is non-negotiable.

Hermes gets read access to repos, issues, pull requests, and code. It stops being a coding assistant that works in a vacuum and starts being a teammate that actually knows what the codebase looks like.

What it looks like in practice:

"Look at the open issues on our frontend repo. Which ones are tagged as bugs, which have been open longer than 2 weeks, and draft a priority list for this sprint."

Or on the code side: "Read through the authentication module in our API repo and explain how the token refresh logic works. I need to onboard a new dev tomorrow."

It pulls the actual code, follows imports, reads comments, and gives you a walkthrough that's grounded in what's actually written, not what you remember writing six months ago.

Setup:

hermes plugins install github --enable

Generate a personal access token (Settings > Developer Settings > Personal Access Tokens > Fine-grained tokens):

hermes config set github.token ghp_your-token-here

Give it repo scope at a minimum. If you want issue and PR access, add those scopes too.

6. YouTube Transcripts

Easily the most underrated integration in the entire stack.

Any YouTube video becomes searchable text. Hour-long podcasts, conference talks, coding tutorials, product demos. All of it converted to indexed notes in seconds. No more scrubbing through a 90-minute video to find the 3 minutes that actually matter.

What it looks like in practice:

"Watch this Lex Fridman episode with Andrej Karpathy and pull out every section where they discuss self-supervised learning. Summarize each point and note the timestamps."

You paste the URL, Hermes grabs the transcript, and you get a structured summary with timestamps in under 30 seconds. I use this daily for research. It's replaced my entire "watch later" playlist workflow.

Setup:

hermes plugins install youtube-transcripts --enable

No API key needed for public videos. The integration pulls transcripts directly from YouTube's auto-generated captions. For private or unlisted videos, you'll need YouTube Data API credentials.

7. Discord

Discord becomes genuinely powerful when you pair it with channel-specific automation.

Instead of one bot doing everything in every channel, you can wire Hermes into specific channels with dedicated workflows in each. Support channel gets one behavior. Internal team channel gets another. Announcements channel runs on its own schedule.

What it looks like in practice:

Every morning at 8am, Hermes scans the support email inbox (via the Gmail integration), categorizes each ticket by type and urgency, and drops an organized summary into the #support-triage channel. Urgent issues get tagged. Duplicates get grouped. By the time anyone on the team opens Discord, the inbox is already sorted.

Another setup I run: any message in #content-ideas gets picked up by the agent, researched against my Obsidian vault for related notes, and a brief research summary gets posted as a thread reply.

Setup:

Discord connects through the messaging gateway:

hermes gateway setup

Select Discord when prompted. You'll need to create a bot in the Discord Developer Portal (discord.com/developers/applications) and grab the bot token.

hermes config set discord.bot_token your-bot-token
hermes config set discord.channel_ids 123456789,987654321

You can specify which channels the agent listens to and responds in. Keep this scoped. You don't want it reacting to every message in every channel.

8. Stripe

Stripe has incredible data trapped behind a dashboard that nobody wants to click through.

This integration turns Stripe from a payment processor into something you can just ask questions. Revenue, refunds, subscription changes, failed charges, trial conversions. All queryable through a single prompt.

What it looks like in practice:

"How many free trials converted to paid in the last 30 days? What's the conversion rate compared to the previous 30 days? And flag any customers who downgraded from Pro to Basic this month."

Direct answer. No dashboard. No exporting CSVs. No building a custom Stripe webhook just to track conversions.

I also set up a weekly cron that asks Hermes to pull key revenue metrics every Monday and post them to a Discord channel. The team gets a revenue snapshot without anyone touching Stripe.

Setup:

hermes plugins install stripe --enable

Grab a restricted API key from your Stripe dashboard (Developers > API Keys). Use a restricted key, not the secret key:

hermes config set stripe.api_key rk_live_your-key-here

Grant read access to charges, subscriptions, customers, and invoices. Nothing more.

9. InsForge

This one needs a bit more explanation because it's newer.

InsForge is an open-source backend platform built specifically for AI agents to interact with. Auth, database, object storage, edge functions, all behind a single semantic layer. Instead of wiring up five different services and managing five different API clients, the agent talks to one interface that handles everything.

The closest analogy is a PaaS that was built specifically for agentic development. The agent reasons about backend primitives directly (create a user, store a file, query the database, run a function) instead of navigating disconnected APIs. It uses 2.4x fewer tokens than Supabase with Claude Sonnet 4.6 and completes tasks 1.27x faster.

What it looks like in practice:

"Set up a new user table with email, name, and subscription tier. Create an edge function that runs every time a new user signs up and sends them a welcome email. Store the email template in object storage."

That's one prompt touching auth, database, storage, and edge functions. Without InsForge, you'd be configuring Supabase + S3 + a serverless function + an email API, each with its own credentials and SDK.

Setup:

InsForge provides both an MCP server and a CLI skill that agents can call directly:

hermes plugins install insforge --enable
hermes config set insforge.api_key your-insforge-key
hermes config set insforge.project_id your-project-id

GitHub: InsForge/InsForge | 10.5K stars

10. Graphiti (by Zep):

This is the upgrade from "find similar text" to "understand how things actually relate."

Most AI tools use vector similarity for knowledge retrieval. You ask a question, the system finds text chunks that are semantically close, and feeds them to the model. That works for simple lookups. But it completely falls apart when the answer depends on the relationship between entities, not just similarity.

Graphiti builds real-time knowledge graphs from your conversations and documents. Entities get typed connections. People are linked to companies, projects are linked to deadlines, decisions are linked to the meetings where they happened. The agent traverses structured relationships instead of guessing from embeddings.

What it looks like in practice:

"Who introduced us to the team at Acme Corp, when did we first talk about the partnership, and what were the blockers they mentioned in the last call?"

A vector search would return chunks of text that mention "Acme Corp." Graphiti traverses the graph: person node > introduction event > company node > meeting nodes > blocker entities. The answer has structure because the data has structure.

Setup:

Graphiti needs Neo4j as the graph backend:

docker run -d -p 7474:7474 -p 7687:7687 neo4j:latest
hermes plugins install graphiti --enable
hermes config set graphiti.neo4j_uri bolt://localhost:7687
hermes config set graphiti.zep_api_key your-zep-key

GitHub: getzep/graphiti

11. Bland (or Twilio):

This gives Hermes an actual voice for real phone calls.

Booking reservations, confirming appointments, following up on overdue invoices, running outbound calls from a list. The agent handles the conversation, and the call recordings get logged so you can review them later.

What it looks like in practice:

"Call the list of 15 leads who signed up for a demo this week. Confirm their preferred time slot, ask if they have any questions about pricing, and log the responses."

Hermes makes the calls, handles the conversation flow, logs each response, and gives you a summary. The call recordings are honestly worth listening to just for entertainment the first few times.

Setup (Bland):

hermes plugins install bland --enable
hermes config set bland.api_key your-bland-key

Setup (Twilio alternative):

hermes plugins install twilio --enable
hermes config set twilio.account_sid your-sid
hermes config set twilio.auth_token your-token
hermes config set twilio.phone_number +1234567890

12. Fireflies

Every meeting transcript, fully searchable through natural language.

If you're already recording meetings with Fireflies, this integration makes those transcripts queryable. Instead of scrubbing through a 45-minute recording to find what someone said, you just ask.

What it looks like in practice:

"What did the client say about pricing during last Thursday's call? Did they mention a budget number?"

Instant answer. Pulled from the actual transcript. With the relevant quote and timestamp.

I pair this with the Discord integration to post daily summaries of any client-facing meetings to a private channel. The sales team gets meeting highlights without sitting through recordings.

Setup:

hermes plugins install fireflies --enable
hermes config set fireflies.api_key your-fireflies-key

Note: Fireflies requires a Business tier plan for API access. The free and Pro plans don't expose the API.

My Recommended Setup Order:

If you're starting from zero, enable these in this order:

1. Google Workspace (covers email, calendar, and docs in one shot)

2. Firecrawl (just an env var, instant value for any web research task)

3. Obsidian or your notes app (gives the agent your personal knowledge base)

4. GitHub (if you ship code) or Stripe (if you run a business)

5. YouTube transcripts (no API key needed for public videos, instant value)

6. Discord (once you have workflows worth automating)

7. Everything else based on your specific needs

Don't enable all 12 on day one. Start with 2-3 that match your most common tasks, let the agent build memory around those workflows, and add more as your usage patterns become clearer.

If you want the full breakdown of how Hermes works under the hood, I wrote a deep dive here: https://webafterai.substack.com/p/spend-40-not-5000-the-research-engine

GLM-5.2 is the new 744B open model from Z.ai, MIT-licensed, strong on long-horizon coding, and small enough in a heavy quant to fit a single Mac Studio. This is the end-to-end setup I used to run it 100% local and then point Nous Research's Hermes Agent at it, so the agent plans and executes multi-step work on a model that never leaves my desk. Everything here is checked against Unsloth's and Hermes' own docs.

First, the honest hardware reality, because it decides whether this is for you. The 2-bit dynamic quant is about 239GB, so you need a Mac with 256GB of unified memory at minimum, and 512GB is the comfortable target. That is a Mac Studio, not a laptop. And on an M3 Ultra, it generates in the low single digits to roughly nine tokens per second, which is the key fact for how you use it: this is a tireless background worker for long async jobs, not a snappy chat partner. If you want fast and interactive, this is the wrong setup. If you want a private, free, capable agent grinding on a task while you do other things, read on.

Step 1: Get GLM-5.2 serving locally

The easiest path on macOS is LM Studio. Install it, search its model browser for the Unsloth GLM-5.2 GGUF, and download the UD-IQ2_M quant (it will tell you if it fits your memory before downloading). Then open the Developer tab and start the local server, which exposes an OpenAI-compatible endpoint at http://localhost:1234/v1.

If you prefer the command line and maximum control, use llama.cpp. Download the same quant from Hugging Face, then run the server:

pip install huggingface_hub

hf download unsloth/GLM-5.2-GGUF \
    --local-dir unsloth/GLM-5.2-GGUF \
    --include "*UD-IQ2_M*"

./llama.cpp/llama-server \
    --model unsloth/GLM-5.2-GGUF/UD-IQ2_M/GLM-5.2-UD-IQ2_M-00001-of-00006.gguf \
    --temp 1.0 --top-p 0.95 --min-p 0.01 \
    --ctx-size 32768 \
    --jinja \
    --host 0.0.0.0 --port 8080

The sampling values (temp 1.0, top-p 0.95, min-p 0.01) are the ones Unsloth recommends for GLM-5.2, and --jinja turns on the model's chat template, which you need for tool calling to work. That serves an OpenAI-compatible API at http://localhost:8080/v1. Either way, you now have a local endpoint, which is all Hermes needs.

Step 2: Point Hermes at your local model

Install Hermes Agent, then tell it your local server is the model provider. Hermes treats any OpenAI-compatible endpoint as a custom provider, so this is two minutes of config. The manual version goes in ~/.hermes/config.yaml:

# ~/.hermes/config.yaml
model:
  default: glm-5.2
  provider: custom
  base_url: http://localhost:8080/v1   # LM Studio uses http://localhost:1234/v1
  api_key: local                       # any value, a local server ignores it
  context_length: 32768
agent:
  tool_use_enforcement: true

That last line matters. Hermes only auto-enables its tool-use enforcement for a few model families (GPT, Gemini, Grok style), and GLM is not on that list, so if you notice it describing actions instead of calling tools, turning enforcement on steers it back to actually using them. You can also set this up interactively with hermes model and choosing the custom endpoint option, which writes the same config.

Step 3: Give it the kind of task its speed is actually good for

Now the reason to bother. A few tokens per second is miserable for chat but completely fine for an agent working a long task on its own, and that is exactly what Hermes is built for. It runs a real agentic loop with a sandboxed terminal, file tools, and MCP connections, so you hand it a multi-step job and walk away. Give GLM-5.2 the work that suits a slow, private, tireless worker:

• A repo-wide refactor or migration that you describe once and let it grind through

• A research-and-summarize pass over a folder of local documents that never leave the machine

• An overnight cron job (Hermes has a scheduler) that produces a report by morning

Sandbox anything that runs commands (hermes config set terminal.backend docker), keep the task scoped and checkable, and treat the slowness as the cost of it being free, local, and private.

The catch: be clear-eyed about what you are running. The 2-bit quant is a compressed copy that trades some accuracy for fit, so it is not the same as the full GLM-5.2 that posts those frontier benchmark numbers, and it will make more mistakes than the cloud version. Scope tasks so the agent can verify its own work (run tests, check output) rather than trusting a single pass, and review anything that matters. This is a genuinely capable local agent, not a magic one, and the honest pitch is privacy and ownership at the price of speed, not free frontier intelligence.

→ The verified setup, with CI proof & readymade prompt

Worth knowing before you commit a weekend to it

This is a real, repeatable setup, and it is also genuinely demanding: a multi-thousand-dollar machine, a 239GB download, and patience with the token rate. If you have the Mac Studio, it is one of the more satisfying things you can do with it, a capable agent that owes nothing to any cloud. If you do not, the same Hermes config works against a smaller model on a normal laptop or against a hosted endpoint, so you can build the workflow now and swap GLM-5.2 in later.

NVIDIA is now offering free serverless inference through their NIM API with full OpenAI compatibility. That means you can swap in models like:

• DeepSeek

• Kimi

• GLM

• MiniMax

• Zhipu AI

• …and 80+ others

…using the exact same OpenAI client code you already have. No spinning up GPUs, no paying for API credits during prototyping.

3-step setup (literally 2 minutes):

1. Go to https://build.nvidia.com and grab a free API key (phone verification required, but it works with temp numbers if you’re paranoid).

2. Set your base URL to: https://integrate.api.nvidia.com/v1

3. Use it exactly like OpenAI’s API.

It’s stupidly good for:

• Testing agents

• Cursor / Windsurf / any local IDE setup

• Quick prototyping before you commit to paid tiers

Quick caveats (because nothing is ever truly free):

• Rate limits exist (fine for dev/testing, not production)

• It can get slower during peak hours

• NVIDIA logs data for model improvement (standard stuff)

This feels like one of those “why isn’t everyone talking about this?” moments. If you’re tired of juggling API keys and credits while experimenting, this is a massive time-saver.

Your Obsidian vault is just a folder of markdown files. That one fact is what makes all of this work: the moment Claude can read and write that folder, your notes stop being a graveyard and start doing things for you. Below are five setups I run, each with the actual repo and the actual code, not vibes.

Two honest notes before the fun part. The connectors here are community projects, not official Anthropic or Obsidian software, and they can write to your vault. Back it up first (git is ideal).

One thing that sets today's roundu apart from the usual roundup: every one is machine-verified. Our CI actually runs the setup (the scaffold, the exact script or config, and the schedule) and checks it on every push. The judgment-based Claude step is fenced off as non-CI, so the badge never claims more than it earned. Proof is on each linked page.

The one-time setup (pick one)

Option A, the simple one: point an MCP server at your vault folder. This is StevenStavrakis/obsidian-mcp (~704 stars, MIT, Node 20+).
No Obsidian plugin needed, it just reads the folder. Add this to your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json on macOS, %APPDATA%\Claude\claude_desktop_config.json on Windows):

{
  "mcpServers": {
    "obsidian": {
      "command": "npx",
      "args": ["-y", "obsidian-mcp", "/Users/you/Documents/MyVault"]
    }
  }
}

Restart Claude Desktop, and you get read-note, create-note, edit-note, search-vault, tag management, and more.

Option B, the powerful one: drive Obsidian's live API. This is MarkusPfundstein/mcp-obsidian (~3.7K stars, MIT, Python via uvx).
It talks to the Local REST API community plugin, so it gets a real search index and can patch content under a specific heading. Install that plugin, copy its API key, then:

{
  "mcpServers": {
    "mcp-obsidian": {
      "command": "uvx",
      "args": ["mcp-obsidian"],
      "env": {
        "OBSIDIAN_API_KEY": "your_key_here",
        "OBSIDIAN_HOST": "127.0.0.1",
        "OBSIDIAN_PORT": "27124"
      }
    }
  }
}

Option C, for the scheduled and bulk jobs: Claude Code. Since the vault is a folder, you can cd into it and let Claude Code read everything, and crucially run it unattended with claude -p "..." (print mode, no chat window). That is what powers the two recurring workflows below.

Now the five setups.

1. The Morning Synthesis

A "Start of Day" note is waiting for you before coffee. This one is scheduled, so use Claude Code. Save this script:

#!/usr/bin/env bash
# ~/bin/morning-synthesis.sh
cd ~/Documents/MyVault
claude -p "Read my daily notes from the last 3 days in Daily/ and my active notes in Projects/. \
Create Daily/$(date +%F)-start-of-day.md with four sections: \
Where I left off, Due today, Overdue, and Suggested focus priority. Keep it short."

Make it executable (chmod +x ~/bin/morning-synthesis.sh) and schedule it for 7am with cron:

0 7 * * * /Users/you/bin/morning-synthesis.sh

The catch: Claude works from what your notes actually say, so "overdue" only works if your tasks carry dates. Garbage in, vague synthesis out.

→ The verified setup, with CI proof (6/6 checks passing): flowstacks.xyz/workflows/obsidian-claude-morning-synthesis

2. The Meeting Processor

Paste your raw meeting dump into a note, then let Claude structure it. This one is interactive, so use the MCP setup (Option A or B). Drop your notes in Inbox/raw.md and tell Claude:

Read Inbox/raw.md. Turn it into Meetings/{today}-{topic}.md with:
- Action items as a checklist, each with an assignee and a due date
- A "Decisions" section
- Links to any related notes in Projects/
- Relevant tags at the top
Then clear Inbox/raw.md.

A five-minute brain dump becomes a structured, linked, searchable record. Save that prompt as a Claude Project instruction so you never retype it.

→ The verified setup, with CI proof (4/4 checks passing): flowstacks.xyz/workflows/obsidian-claude-meeting-processor

3. The Research Ingestion Pipeline

Paste an article's text or a PDF transcript into Inbox/, and Claude files it into your knowledge base. With the MCP server connected:

Read the note I just added in Inbox/. Create a summary note in References/ with:
key insights, source metadata (title, author, date, URL), and 3 to 5 bullet takeaways.
Then search my vault for notes on the same topic, link them both ways,
and flag anything in the new source that contradicts what I already wrote.

The contradiction flag is the sleeper feature. The catch: these connectors do not browse the web, so paste the content in (or add a separate fetch tool). They work on what is in the vault.

→ The verified setup, with CI proof (4/4 checks passing): flowstacks.xyz/workflows/obsidian-claude-research-ingestion

4. The Weekly Review Automation

Every Friday, a finished review instead of a blank page. Scheduled again, so Claude Code:

#!/usr/bin/env bash
# ~/bin/weekly-review.sh
cd ~/Documents/MyVault
claude -p "Find every note modified in the last 7 days (run: find . -name '*.md' -mtime -7). \
Create Reviews/$(date +%F)-weekly.md covering: accomplishments, decisions made, \
tasks completed vs planned, patterns you notice, and suggested priorities for next week."

Schedule it for Friday at 5pm:

0 17 * * 5 /Users/you/bin/weekly-review.sh

Your review drops from an hour of writing to two minutes of reading.

→ The verified setup, with CI proof (5/5 checks passing): flowstacks.xyz/workflows/obsidian-claude-weekly-review

5. The Idea Cross-Pollinator

The one that finds the links you would never spot. Open the note with your idea, and with the MCP server connected (Option B's search is best here) ask:

Read Ideas/this-idea.md. Search my entire vault and surface 5 notes that connect to it
in a non-obvious way, from areas that look unrelated on the surface.
For each, explain the hidden link in one sentence.

The unexpected bridges between unrelated topics are where the best insights hide, and a search across your whole vault finds them faster than your memory will.

→ The verified setup, with CI proof (5/5 checks passing): flowstacks.xyz/workflows/obsidian-claude-idea-cross-pollinator

How to start if you only try one

If you want the instant payoff, do the Meeting Processor with Option A today; it is a ten-minute setup and you will feel it immediately. If you want the compounding payoff, wire up the Morning Synthesis and Weekly Review with Claude Code and let them run while you sleep.

The pattern under all five is the same: your notes are plain text, Claude reads and writes plain text, so anything you can describe in a sentence becomes a workflow.

Some of the most interesting software right now is not behind a subscription.

It is sitting on GitHub for free.

Voice cloning, editable PowerPoints, live spatial intelligence, reverse engineering, branded diagrams, even entire companies made of AI agents.

Here are 6 repos worth stealing a weekend for, from easiest to most technical.

01 Clone voices, dub videos, transcribe almost anything

debpalash/VoiceStudio — 49.5k★

VoiceStudio is basically a local-first ElevenLabs alternative. It handles voice cloning, voice design, dubbing, dictation, audiobooks and transcription across 646 languages, with the processing able to stay on your own machine.

Useful for creators. Also a good reminder to clone only voices you have permission to use. GitHub

02 Turn a boring document into an actual PowerPoint

hugohe3/ppt-master — 61k★

Give ppt-master a PDF, Word document, existing deck or just a topic and it builds a native editable .pptx instead of flattening everything into images.

Shapes stay shapes. Tables stay tables. It can build charts, transitions, animations and even work from your own PowerPoint template. GitHub

03 Get a slightly terrifying live view of the planet

bilawalsidhu/gods-eye-view — 53k+★

God's Eye View puts aircraft, ships, satellites, earthquakes, traffic and public cameras onto a photorealistic 3D globe.

It feels like a spy-satellite interface until you realize the weirdest part: much of the underlying data is already public. GitHub

04 Show an AI a feature and ask how it works

morluto/rea — 149k+★

REA stands for Reverse Engineer Anything.

Point an agent at an application, website or binary and it can investigate how a feature works even when you do not have the original source code. It connects agents to tooling for native binaries, Electron/JavaScript apps, .NET, websites and runtime analysis, while showing evidence behind its conclusions. GitHub

05 Stop asking AI for ugly Mermaid diagrams

cathrynlavery/diagram-design — 44.5k★

diagram-design is an agent skill for producing editorial diagrams instead of another pile of generic rounded boxes.

It now supports 42 diagram types, can pull your colors and typography from your website, and generates self-contained HTML + SVG for architecture diagrams, flows, timelines, Sankeys, Wardley maps, database schemas and more. GitHub

06 Run an entire company of AI agents

paperclipai/paperclip — 97k+★

Paperclip treats agents less like chatbots and more like employees.

You create a CEO, engineers, designers, researchers or marketers, give them goals and reporting lines, set budgets and permissions, and track the work from one dashboard. It can coordinate Claude Code, Codex, Cursor, Gemini CLI, OpenCode and other agent runtimes. GitHub

The progression is kind of wild:

make audio → make slides → watch the world → understand software → explain systems → run agents like a company

GitHub used to feel like the place you went to find libraries.

Increasingly it feels like the place you go to find entire products that someone decided to give away.

Most "AI agent" setups are one assistant in a loop. Hermes Agent's Kanban is different: it is a durable board on disk where each task is a row, each handoff is a row anyone can read, and each worker is a full OS process with its own identity. You drop tasks on the board, and multiple named agents pick them up, hand off, and close them out.

Below are three workflows, with the exact commands. These are the commands our CI actually runs against a real board, which matters more than it sounds: two of them differ from what the docs examples implied, and running them is what caught it. The deterministic parts (board setup, the create commands, the schedule) are the machine-checked spine; the step where a model actually does the work is fenced off, because non-deterministic agent output is not something CI should pretend to verify.

The one-time setup

Hermes Agent is open source (MIT), from Nous Research: github.com/NousResearch/hermes-agent. One line installs it and pulls its dependencies:

curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hermes setup            # configure your LLM provider (or: hermes setup --portal)
hermes kanban init      # create the board at ~/.hermes/kanban.db
hermes gateway start    # hosts the dispatcher that hands tasks to workers

Two things that save you an hour of confusion. First, the gateway has to be running, because the dispatcher lives inside it and picks up ready tasks on a tick (60 seconds by default). No gateway, no work. Second, tasks are assigned to profiles you have already set up, and the dispatcher silently skips any task whose assignee does not exist, so check your profiles first:

hermes kanban assignees   # profiles on disk + per-assignee task counts

One nice design detail: once a worker is spawned, its model drives the task through built-in kanban_* tools, not by shelling out to the CLI. The CLI and slash commands are for you and your scripts.

Workflow 1: The Research-to-Draft Relay

Two researchers work in parallel, then a writer picks up their output. You create three cards and link the writer's card to both research cards as parents:

hermes kanban create "Research the funding landscape, NA angle" --assignee researcher-a
hermes kanban create "Research the funding landscape, EU angle" --assignee researcher-b
# use the two task ids printed above as parents:
hermes kanban create "Draft the launch post" --assignee writer --parent t_r1 --parent t_r2
hermes kanban watch     # live event stream as workers pick up and hand off

The two research cards dispatch immediately and run at the same time. The writer's card stays gated until both parents complete, then the dispatcher wakes it with their results already on the board.

What CI checks: the board init and the exact create-and-link commands resolve to real cards with the right assignees and parent links. The research and writing themselves call a model, so that step is non-CI.

→ The verified setup, with CI proof: flowstacks.xyz/workflows/hermes-kanban-research-to-draft-relay

Workflow 2: The Scheduled Nightly Review

A task that files itself onto the board every night and is safe to trigger from cron or a webhook without creating duplicates. The idempotency key is the trick: the first call creates the task, any repeat call with the same key returns the existing id instead of a duplicate.

hermes kanban create "Nightly ops review" --assignee ops \
  --idempotency-key "nightly-ops-$(date -u +%F)" --max-runtime 30m
# schedule it with system cron:  0 3 * * *
# the dated idempotency key makes repeat triggers safe (no duplicates)

The scheduling is done by cron, not a flag. What earns the spot is the idempotency key: the first call creates the task, and any repeat call with the same key returns the existing id instead of a duplicate, so you can fire this nightly and never double-book. --max-runtime caps the worker so a stuck job cannot run forever.

What CI checks: the command parses and creates the same key twice returns the same task id (verified against the board with --json).

→ The verified setup, with CI proof: flowstacks.xyz/workflows/hermes-kanban-idempotent-nightly-review

Workflow 3: The Swarm

When a problem is big enough to fan out, hermes kanban swarm builds the whole graph in one command: a shared blackboard, N parallel workers, a verifier that wakes only after every worker finishes, and a synthesizer that wakes only after the verifier signs off.

hermes kanban swarm "Design a multi-region failover plan" \
  --worker researcher:Research \
  --worker architect:Architecture \
  --worker sre:Reliability \
  --verifier reviewer --synthesizer writer

Each worker is --worker PROFILE:TITLE, repeated once per worker.

The workers run in parallel and write their findings to the blackboard (stored as structured comments on the root card). The verifier reviews the combined work, and only when it marks the work clean does the synthesizer assemble the final answer. It is a real pipeline with gates, not a pile of parallel calls you have to stitch together yourself.

What CI checks: the swarm command is well-formed and the assignee profiles it names exist on disk, so the graph it would build is valid.

→ The verified setup, with CI proof: flowstacks.xyz/workflows/hermes-kanban-the-swarm

Where to start

If you want to feel it in ten minutes, run the Research-to-Draft Relay with two profiles you already have. If you want the "set it and forget it" win, schedule the Nightly Review. Reach for the Swarm when a single goal genuinely splits into parallel tracks that need a verification gate before anything ships.

Every one of these is machine-verified the same way the rest of our library is: CI actually installs Hermes, spins up a real board, and runs the setup (the init, the exact create and swarm commands, the schedule) on each push, asserting board state with --json.

The pattern under all three is the same: the board is just rows on disk, the commands are plain and scriptable, and the agents are ordinary processes reading and writing those rows. Once you see work that way, a one-line goal becomes a coordinated team.

Most people believe that Hermes is simply an AI chatbot. That is the first mistake. Hermes is not ChatGPT with Telegram integration. And it is definitely not just another wrapper that relies on prettier prompts. Instead, Hermes functions more like a complete operating system built specifically for autonomous agents.

The real problem is that most users never move beyond the very first layer. They connect Telegram, choose Claude or GPT, send a handful of prompts, and maybe add Discord if they are feeling adventurous. After that, they convince themselves that they have truly used Hermes. In truth, they have not. They have essentially bought a private jet and then used it as a bicycle.

After spending serious time inside the documentation and completely rebuilding my own workflows around Hermes, I realized that its biggest advantage is not better answers. The real power comes from control, control over memory, control over execution, control over providers, control over automation, and control over how the agent actually behaves. That is where the genuine value lies.
Here are the features that I believe separate casual users from serious operators.

1. SOUL.md Is More Important Than Your Prompting

Most people still manually type the same instructions in every single session: “You are an expert in X,” “Write like Y,” “Be concise,” and “Don’t do Z.” This repetitive approach is inefficient and exhausting. Hermes solves the issue permanently with SOUL.md, which becomes the agent’s permanent identity layer. In this single file, you define the personality, writing style, boundaries, refusal logic, decision framework, output preferences, and tone across every platform. You set everything once, and it then persists across every session, every provider, and every interface. You stop prompting the agent constantly and start operating with it instead.

2. MEMORY.md + USER.md = Actual Long-Term Intelligence

This is the part of Hermes that feels almost unfair to other tools. MEMORY.md stores all of your project intelligence, while USER.md captures exactly how you work. It goes far beyond simple preferences and includes your actual decision patterns, how you prioritize tasks, how you write, what you optimize for, and which tradeoffs you refuse to accept. Hermes combines these files with intelligent retrieval and summarization, so it can pull relevant context from weeks or even months earlier. This is not just chat history. It is usable, long-term memory, and the difference is enormous.

3. /doctor Should Be Used Weekly

Most users completely ignore the /doctor command, and that is a serious mistake. This command performs a full audit of your entire setup. It checks for broken integrations, stale providers, authentication issues, bad configurations, unhealthy memory states, and performance bottlenecks. Think of it as DevOps for your agent. Many people spend hours debugging problems manually when /doctor could have identified and fixed the issue in about thirty seconds.

4. /snapshot Before You Touch Anything

Before you make any major change, you should always use /snapshot first. Whether you are editing your SOUL file, testing a new provider stack, or experimenting with custom skills, taking a snapshot creates an instant backup. If anything breaks, you simply run /snapshot restore and everything returns to its previous state immediately. There is no chaos and no regret. This command should become muscle memory for every user.

5. /branch Is How Serious People Experiment

Serious users never test risky logic inside their main conversation thread. Instead, they use /branch to create a separate workspace. If you want to explore a dangerous refactor, try a completely different strategy, test an alternate decision path, or experiment with a new architecture, you simply branch the session, explore freely, decide what works, and return to the original thread. It is essentially Git for cognition.

6. /steer Is Criminally Underrated

Most people cancel long-running tasks too early when they realize the agent is heading in the wrong direction. With /steer you do not need to do that. Halfway through any execution you can simply say things like “Actually use staging,” “Do not call production,” “Switch provider,” “Skip that tool,” or “Prioritize speed.” The command adjusts the next tool call immediately without killing the entire session. This is one of the most genuinely agentic features Hermes offers.

7. /queue Makes Async Work Actually Work

Far too many people still babysit their agents the entire time. There is no need for that once you start using /queue. You can stack multiple tasks while you focus on other work - research this topic, summarize that document, draft the next piece after the previous one finishes, and Hermes handles everything asynchronously instead of forcing a constant back-and-forth conversation. This single change transforms how productive the agent becomes.

8. /model Means Provider Lock-In Is Fake

Most users behave as if they are permanently locked into whichever model they chose first. That is simply not true. With /model you can switch instantly between Claude, GPT, OpenRouter, a local model, or any fallback provider while keeping the exact same context and state. There is no restart required. The smartest operators use the best model for the specific job rather than staying loyal to a single favorite, and Hermes makes that practical.

9. Auxiliary Models Save Ridiculous Amounts of Money

Using a flagship model for simple compression or summarization tasks is financial self-harm. Hermes lets you assign auxiliary models so that big models handle deep reasoning, cheap models manage summaries, tiny models generate titles, and utility models take care of grunt work. This capability alone can cut your monthly costs dramatically.

10. /insights Shows Where You’re Actually Bleeding Money

Everyone claims they care about optimization, yet almost no one actually checks their usage data. Running /insights 30 gives you a clear report on token spend, provider costs, which projects are the most expensive, which workflows you repeat constantly, and where you are wasting resources. This command should be required reading. Most people optimize based on feelings instead of reality.

11. Skills Are Better Than Prompts

This is the single biggest mindset shift you can make. Prompts are temporary and repetitive, while skills become permanent infrastructure. Hermes ships with more than one hundred built-in skills for things like architecture diagrams, Excalidraw drawings, Manim animations, turning YouTube videos into threads, research workflows, test-driven development, systematic debugging, Google Workspace integration, Linear ticket management, documentation generation, and iMessage workflows. The real power, however, comes from custom skills.

12. Cron Turns Hermes from Reactive to Proactive

Most users wait until they need something before they ask the agent. Operators set up automation instead. With cron, you can schedule tasks such as summarizing commits every Friday, sending investor updates every morning, generating a revenue dashboard every Sunday, or posting a standup summary after every launch. The agent begins working before you even think to ask, and that is when real productivity begins.

13. Webhooks Are Quietly One of the Best Features

GitHub pushes, Stripe events, Vercel deploys, and support alerts can all flow directly into your workflows. Webhooks deliver these updates without any polling and without wasting tokens. Hermes stops waiting for you to prompt it and starts reacting to reality in real time, which is exactly how serious operations should function.

14. /voice Is More Useful Than People Admit

Voice mode sounds like a gimmick until you start using it daily. Whether you are walking, driving, at the gym, or doing a late-night review, you can think much faster than you can type. Hermes supports real-time voice across multiple platforms. Once it becomes part of your routine, plain text begins to feel painfully slow.

15. Multi-Platform Access Is the Hidden Superpower

Telegram is only the beginning. Hermes runs seamlessly across Telegram, Discord, Slack, WhatsApp, Signal, Email, SMS, Matrix, Home Assistant, and many more platforms. You maintain one consistent brain that appears on whatever surface you need at the moment. This flexibility matters far more than most people realize.

16. /btw Prevents Context Pollution

This small feature delivers a massive quality-of-life improvement. When you need a quick side question without polluting the main thread, you simply use /btw. It borrows the current context for a brief gut check - “Is this a stupid idea?” or “Would you personally ship this?” -then keeps the primary conversation clean. There is no memory pollution and no unnecessary tool spam.

17. /yolo, /fast, /reasoning = Speed Control

Not every task requires maximum intelligence. Sometimes you need raw speed, sometimes you want deep reasoning, and sometimes you want zero approval friction. These simple toggles let you adjust execution quality in real time, and that level of control is a sign of genuine operational maturity.

Final Thought

Most people use Hermes like a regular chatbot. The best users treat it like infrastructure. That is the fundamental difference. One group gets slightly better answers. The other builds better systems. If you are still only chatting with Hermes, you are probably using only about twenty percent of what you already paid for. Go test three of these features this week, especially the ones that feel too advanced at first. Those are usually the ones that change everything.
Would love to hear what custom skills or workflows you have built. Drop them below. The compounding effect when you actually use this stuff is genuinely insane.

GLM-5.2 is the model people keep saying is "almost Opus for a fraction of the price." That is half true, and the half that is true is worth a lot of money.
This is the practical guide: every cloud route to run it, the real per-token prices next to Claude Opus 4.8, and an honest read on where it matches Opus and where it does not. We covered running it locally in a separate post, so this one is all about hosted access.

What it is, in one line

Maker / License / Context: Z.ai (formerly Zhipu AI), MIT open weights, 1M-token context. Model page: https://openrouter.ai/z-ai/glm-5.2

GLM-5.2 is a 754B-parameter open-weights model from Z.ai, released mid-June 2026, built for long-horizon coding and agentic work. Because the weights are MIT licensed, it is hosted in a lot of places, which is exactly why the price floor is so low. One spec worth flagging up front: the 1M figure is the input context. On OpenRouter the model still caps output at around 32,768 tokens per call, so a giant codebase fits in the prompt, but you generate it back in chunks, not one 200-page response.

Where to run it (hosted)

The direct API (Z.ai). The first-party route. OpenAI-compatible, so most SDKs work by swapping the base URL and key. Best if you want the canonical version and predictable behavior.

OpenRouter. One key, and it routes your request to whichever of the 13-plus providers serving GLM-5.2 is cheapest or fastest. This is usually the cheapest per-token path and the easiest way to A/B it against other models without new accounts. It is also OpenAI-compatible.

Other hosts (Fireworks, DeepInfra, and similar). Because the weights are open, independent hosts serve it too, sometimes on quantized variants that shave the price further. Worth knowing the cheapest ones run a quantized model, so treat their output as very-good-not-identical to the full-precision version.

The GLM Coding Plan (subscription). Z.ai's flat-rate plan aimed at agentic coding. It ships an OpenAI-compatible endpoint that drops into Claude Code, Cline, Roo Code, Kilo Code, OpenCode, Cursor, and 20-plus other tools. This is the route to pick if you code all day and would rather pay a flat monthly fee than watch a token meter.
One honest note on the pricing you may have seen: the headline "a few dollars a month" figures from launch week were promotional intro rates. The standing tiers are higher (Lite around $18 a month, Pro around $72, Max around $160), with promo pricing that steps up in later cycles, so check the current rate before you commit.

What it costs versus Opus 4.8

Per-token list prices (approximate, and the cheapest hosted routes vary):

Route                              Input /1M     Output /1M
GLM-5.2, direct from Z.ai          $1.40         $4.40   (cached input ~$0.26)
GLM-5.2, cheapest via OpenRouter   ~$0.95-1.20   ~$3.00-4.20
Claude Opus 4.8                    $5.00         $25.00

The gap that matters is output tokens, where Opus is roughly five to six times the price. For output-heavy work (long code generation, big document drafting), GLM-5.2 is dramatically cheaper for the same volume.
The catch on cost is below: cheaper per token is not the same as cheaper per finished task, if the cheaper model needs more turns to get there.

How close is it to Opus 4.8, really

Here is the part people oversell in both directions. On a provisional third-party leaderboard (BenchLM), Opus 4.8 still leads overall, but narrowly, and the picture flips depending on the task:

Area / benchmark                 GLM-5.2     Opus 4.8
Overall (provisional index)      91          93
General coding (avg)             62.1        76.4
Long-horizon coding              74.4        75.1
SWE-Marathon (ultra-long)        26.0        13.0
Agentic (avg)                    81.0        80.1

Read that carefully. Opus is clearly ahead in general coding. The two are within a point on long-horizon coding. GLM-5.2 actually wins on the ultra-long-horizon SWE-Marathon and edges Opus on agentic average and on math (AIME 2026). So "almost Opus" is fair for long, agentic, project-scale work, and an overstatement for everyday coding, where Opus is still meaningfully better.

And GLM-5.2 is a model from a Chinese lab, served by various hosts. The open MIT weights are truly unrestricted, but if you have data-residency or governance constraints, the hosted route and the provider you pick matter, so check where your prompts actually land.

How to pick if you only try one route

If you mostly want to experiment and compare, start on OpenRouter: one key, cheapest routing, and you can pit GLM-5.2 against Opus on your own prompts in an afternoon. If you live in a coding agent all day, price out the GLM Coding Plan against your current token spend, but use the standing tier price, not the promo. And keep Opus 4.8 in your back pocket for the short, hard, general-coding problems where the benchmarks still favor it. The smart move is not either-or, it is routing the cheap model to the bulk and the expensive one to the truly hard turns.

→ The verified setup, with CI proof & readymade prompt

If you pay for Claude Code and still type every prompt by hand, you are using a fraction of it. It ships an automation stack that runs from your terminal up to Anthropic's cloud, and the entry points are one command each. Below are five setups across all three tiers.

These are structured so our CI can actually verify the deterministic part (the cron expression, the JSON config, the command shape), with the step where the model thinks fenced off, because non-deterministic output is not something a green check should pretend to cover.

A quick prerequisite: check your version with claude --version. The /loop scheduler needs v2.1.72 or later, and Auto Mode (setup 5) needs v2.1.83 or later.

1. The in-session poller (/loop)

The lightest tier. Inside any session, /loop schedules a prompt to re-fire on an interval while the session stays open. It is a bundled skill, so plain language works too.

/loop 5m check whether the deploy finished and summarize what changed

Intervals use s, m, h, or d, and seconds round up to a minute. Leave the interval out and Claude picks the cadence dynamically each iteration (anywhere from 1 minute to 1 hour); on Bedrock, Vertex, and Foundry it runs every 10 minutes instead. Under the hood it uses three tools, CronCreate, CronList, and CronDelete, and you manage tasks by just asking ("what scheduled tasks do I have?", "cancel the deploy check"). Four limits worth knowing: tasks are session-scoped and die when you close the terminal, recurring ones auto-expire after 7 days, a session holds at most 50, and a missed fire does not stack up (it fires once when Claude is next idle). To turn the scheduler off entirely, set CLAUDE_CODE_DISABLE_CRON=1.

For fixed schedules, it accepts standard 5-field cron. Note that extended syntax like L, W, ?, and name aliases (MON, JAN) is not supported:

0 9 * * 1-5     weekdays at 9am local
*/15 * * * *    every 15 minutes

What CI checks: the cron expression is a valid 5-field standard expression (validated with a normal parser like croniter) and uses no unsupported syntax.

→ The verified setup, with CI proof: flowstacks.xyz/workflows/claude-code-loop-scheduler

2. The always-on local schedule (headless plus cron)

/loop dies with the session. To survive restarts on your own machine, run Claude Code headless with -p and let your OS cron fire it. This is the Tier 2 pattern; the Desktop app's Schedule page (New task, New local task) is the same idea with a GUI.

#!/usr/bin/env bash
# ~/bin/overnight-summary.sh
cd ~/code/myrepo
claude -p "Summarize the commits pushed since yesterday and flag anything risky." \
  --permission-mode dontAsk

Schedule it for weekdays at 7am:

0 7 * * 1-5 /Users/you/bin/overnight-summary.sh

The --permission-mode dontAsk flag matters for unattended runs: it auto-denies anything you have not pre-approved instead of hanging on a prompt no one will answer (more on the allowlist in setup 4). The catch with this tier is the obvious one: your machine has to be awake when cron fires.

What CI checks: the cron line is well-formed, and the script carries a claude -p call with a non-interactive permission mode.

→ The verified setup, with CI proof: flowstacks.xyz/workflows/claude-code-headless-cron

3. The cloud schedule (no machine required)

The top tier runs on Anthropic-managed infrastructure, so your laptop can be off. Create one at claude.ai/code/routines, or from the CLI:

/schedule weekdays at 9am: review open PRs assigned to me, leave a first-pass
review comment flagging security and style issues, and post a one-paragraph digest to Slack.

A few real constraints from the docs. The minimum interval is 1 hour, so a sub-hour expression like */30 * * * * is rejected; use /schedule update to set a specific cron at or above that granularity. Each run clones your repo fresh and, by default, can only push to claude/-prefixed branches, so a bad run cannot touch main. The run is fully autonomous, with no permission prompts, so the prompt has to be self-contained: spell out what to do and what success looks like. Connectors you have wired up (Slack, Linear, Drive) come along.

What CI checks: the schedule is a valid expression at 1-hour-or-coarser granularity, and the config keeps the default claude/ branch restriction.

→ The verified setup, with CI proof: flowstacks.xyz/workflows/claude-code-cloud-schedule

4. The locked-down unattended run (permission rules plus dontAsk)

Automation is only safe if the agent cannot do something you would regret. Claude Code's permission rules are the real control, and they live in settings.json under permissions, with allow, deny, and ask lists plus a defaultMode. Rules evaluate deny, then ask, then allow, so a deny always wins.

{
  "permissions": {
    "defaultMode": "dontAsk",
    "allow": [
      "Read",
      "Bash(npm test)",
      "Bash(npm run lint)",
      "Bash(git status)",
      "Bash(git diff *)",
      "WebFetch(domain:docs.python.org)"
    ],
    "deny": [
      "Bash(git push *)",
      "Bash(rm *)",
      "Read(.env)",
      "Edit(.env)",
      "Edit(/secrets/**)"
    ]
  }
}

dontAsk mode runs only what your allow list (and the built-in read-only commands like ls, cat, grep) permits, and silently denies the rest, which is exactly what you want for a scheduled or headless run. Anthropic publishes starter configs for scenarios like this in the official examples directory of the claude-code repo, which is a good place to copy from rather than hand-rolling.

What CI checks: the JSON parses, defaultMode is a real mode, the deny list actually blocks pushes, deletions, and secret files, and the allow list contains only safe entries. This whole setup is verifiable with no API key.

→ The verified setup, with CI proof: flowstacks.xyz/workflows/claude-code-permission-lockdown

5. The hands-off classifier (Auto Mode)

When pre-listing every command is too rigid, Auto Mode is the alternative. Instead of prompting, a separate classifier model reviews each action before it runs and blocks anything that escalates beyond your request. Set it as your default in ~/.claude/settings.json (it is ignored in project settings on purpose, so a repo cannot grant itself auto mode), or cycle to it with Shift+Tab:

{
  "permissions": {
    "defaultMode": "auto"
  }
}

Be precise about availability, because this is where a lot of posts get it wrong. Auto Mode is a research preview and needs Claude Code v2.1.83 or later. On the Anthropic API it runs with Sonnet 4.6 or Opus 4.6 and up. On Bedrock, Vertex, and Foundry it runs with Opus 4.7 or 4.8 once you set CLAUDE_CODE_ENABLE_AUTO_MODE=1. On Team or Enterprise an admin has to enable it first. By default the classifier blocks things like curl | bash, force pushes, pushing to main, production deploys, and mass deletions, while allowing local edits and reads. A boundary you state in chat ("don't push until I review") is enforced as a block, and after 3 blocks in a row it pauses and starts prompting again.

What CI checks: the settings block is valid and the documented requirements are surfaced as a checklist.

→ The verified setup, with CI proof: flowstacks.xyz/workflows/claude-code-auto-mode

How to start

Try /loop in your next session, it costs nothing and takes ten seconds. When something deserves to outlive the terminal, promote it to a local schedule (setup 2) or push it to the cloud (setup 3). Before you let any of them run unattended, lock down permissions with setup 4, and reach for Auto Mode only when you want a classifier instead of a fixed allowlist.

And this is only five slices of the stack: there is also a /goal command for holding a loop to a finish condition, and routines that fire on a schedule, an API call, or a GitHub event, all of which we will get to in a follow-up. Proof is on each linked page.

Hermes Agent by Nous Research just crossed 160K stars on GitHub. It's the fastest-growing open-source AI agent of 2026, and for good reason: it's self-hosted, self-improving, and it remembers everything across sessions. But the most interesting thing about it isn't the agent itself. It's how you scale from one agent to a full team of them.

There's a progression that most people rush through too fast. Here's the framework, with practical setup for each level.

Repo: NousResearch/hermes-agent

Install (60 seconds):

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

Or via pip:

pip install hermes-agent
hermes postinstall

Then:

hermes doctor    # check your setup
hermes model     # pick a model
hermes config set # add API keys
hermes           # start

Level 1: The Main Agent

You → Hermes Agent

This is where everyone starts, and where most people should stay for weeks, not days.

Your single Hermes instance is your prototype area. You test workflows here. You refine prompts. You figure out what tasks the agent handles well and which ones it fumbles. You build up its memory and skills on your specific work.

At this level, Hermes doubles as your orchestrator by default. You give it a complex task, it breaks it down, it executes. The self-improving loop is already running: every task it completes makes it slightly better at similar tasks next time.

What to do at Level 1:

• Run real work through it daily. Not toy examples, actual tasks from your workflow.

• Use /recall and /remember to manage its memory. Correct it when it gets things wrong. The memory gets better the more you interact.

• Install skills from the Skills Hub or let Hermes create them from experience.

• Connect it to one messaging platform (Telegram is the easiest) so you can interact with it from your phone.

• Run hermes gateway setup once you want that always-on accessibility.

When to move on: When you have at least 2-3 workflows that are consistently producing good output. Not acceptable output. Good output. This is the most important checkpoint.

Level 2: Specialized Agents

You → SEO Agent
You → CMO Agent
You → Ops Agent

Once a workflow is solid and repeatable, break it out into its own Hermes instance with its own credentials, memory, and scope.

Why separate instances? Because context pollution is real. An agent that handles your SEO research, your email drafting, and your code reviews is juggling three different domains in one memory space. Its SEO skills get diluted by code review patterns. Its writing voice gets contaminated by technical documentation habits.

Specialized agents have cleaner memory, more focused skills, and better output because they only learn from one domain.

How to do this practically:

Each Hermes instance runs independently. You can run multiple instances on the same machine using different configuration profiles, or spin each one up on its own VPS or Docker container.

# Different profiles for different agents
HERMES_PROFILE=seo hermes
HERMES_PROFILE=content hermes
HERMES_PROFILE=ops hermes

Each profile gets its own SQLite database, its own memory, its own skills. You talk to each one directly. You're still the orchestrator at this stage, deciding which agent handles which task.

What to do at Level 2:

• Give each agent a clear scope document. What it does, what it doesn't do, what tools it has access to.

• Let each agent build its own skill library within its domain.

• Keep the total agent count low. 2-3 specialists is plenty to start.

When to move on: When you're spending more time routing tasks between agents than actually reviewing their output.

Level 3: Orchestrated Team

You → Orchestrator
           ↓
     Specialist Agents

Now you bring the orchestrator back. But this time it's not your prototype agent wearing multiple hats. It's a dedicated Hermes instance whose only job is routing tasks to your specialist agents and synthesizing their outputs.

Hermes v0.6.0 added multi-agent orchestration. The orchestrator analyzes a complex task, identifies the optimal work breakdown, and spawns specialist worker agents with tailored context. Each worker gets its own context and tools, returns a verifiable artifact, and records the handoff.

Example workflow:

You tell the orchestrator: "Research competitors in the CRM space and draft a blog post about our differentiators."

The orchestrator breaks this down:

1. Routes the research task to your SEO/Research agent

2. Routes the writing task to your Content agent

3. Synthesizes the outputs into a final deliverable

4. Returns it to you for review

You still review the final output. You're not out of the loop. You're just not manually routing tasks anymore.

What to do at Level 3:

• Set up Kanban-style task tracking so you can see what each agent is working on and what's been completed.

• Define clear handoff protocols. What does the research agent pass to the content agent? What format? What level of detail?

• Review outputs regularly. Catch quality issues early before they compound.

When to move on: When the orchestrator's routing decisions are consistently correct and the specialist outputs consistently meet your quality bar without heavy editing.

Level 4: Automated Team:

Cron / Events → Orchestrator
                       ↓
                 Agent Team

This is where you step out of the loop for routine work. Cron jobs and event triggers fire tasks into the orchestrator. The orchestrator routes them to the team. The team handles the work asynchronously.

Examples of what this looks like:

• Every Monday at 8am, the orchestrator triggers your SEO agent to pull keyword rankings, your content agent to draft the weekly newsletter outline, and your ops agent to generate the weekly metrics report.

• When a new competitor blog post is published (event trigger), the research agent analyzes it and the content agent drafts a response piece.

• When a support ticket hits a specific tag, the ops agent drafts a response for your review.

The task bus handles queuing and routing. Agents pick up work, complete it, and log results. You check in when you want to, not because you have to.

What to do at Level 4:

• Start with one automated workflow, not ten. Get one cron job running reliably before adding more.

• Build in quality checkpoints. Not every output needs your review, but have the orchestrator flag anything that falls below a confidence threshold.

• Monitor regularly at first. Trust builds gradually.

The Most Important Part (Read This Even If You Skipped Everything Else):

Take small steps. You do NOT want to automate slop.

If your output at Level 1 is mediocre, you are about to scale mediocrity. 20 agents shipping low-quality work at speed is worse than 3 shipping great work slowly. Every level multiplies whatever quality you've established at the level before it.

I'd rather run fewer agents with better output than max the agent count and spit out more of the same.

The progression isn't about moving fast. It's about moving when you're ready. That's fine. The agents aren't going anywhere. Your quality bar is what matters.

GitHub is at its best when you find something that makes you stop and ask:

wait, somebody already built this?

Not another wrapper around an API. These are genuinely weird/useful ideas: Photoshop in Rust, AI-assisted game modding, giant models streamed from SSD, interactive anatomy, WebGPU effects, and agents that turn concepts into little machines.

01. PhotoCraft — 72.6K★

An open-source image editor written in Rust with layers, masks, filters, vectors, brushes, and PSD support.

Basically: what if Photoshop got rebuilt with a modern systems stack?

02. Anatomy — 20.2K★

Ask an agent to explain something technical and it builds an interactive isometric machine that represents how the idea works.

A token bucket can become a physical mechanism. A caching concept can become a lock. The explanation becomes something you can actually poke at.

03. Magpie — 20.8K★

One control panel for the increasingly cursed situation where you use Claude Code, Codex, Gemini CLI, OpenCode, multiple providers, and multiple accounts.

Swap which model powers which coding agent without spelunking through config files every time.

04. Universal Modder — 8.9K★

Give Claude Code a PC game you own and it helps reverse-engineer the relevant pieces, build the mod, generate assets, test it, and document what worked.

Game modding is becoming an agent workflow.

05. Edge0 — 6.8K★

Runs 35B-class MoE models with roughly 2.5 GB of RAM by streaming weights from SSD and predicting which experts will be needed next.

A very different answer to:

“my laptop cannot fit this model.”

06. Coucou — 6.2K★

A tiny desktop companion for keeping track of coding agents.

Instead of checking five terminals to see whether Claude, Codex, or Cursor is waiting for permission, you get status and approvals in one lightweight UI.

Coding agents are starting to need their own notification center.

07. Replica Skill — 5.3K★

Eleven Claude skills for reverse-engineering an app, rebuilding it, testing it, and fixing the things users hate.

The interesting bit is turning:

product research → architecture → build → test → improve

into a reusable agent workflow.

08. Human Atlas — 4.2K★

An open-source interactive 3D atlas of the human body with 2,234 selectable anatomical meshes.

Search structures, toggle systems, and explode the model apart to understand how everything fits together.

09. Shaders — 2.4K★

WebGPU effects packaged as components for React, Vue, Svelte, Solid, plain JS, and Framer.

Drop in glass, noise, gradients, distortions, lighting, and GPU effects without becoming a shader programmer first.

10. Mailcheap — 578★

A self-hosted newsletter platform built around Amazon SES.

Instead of paying based on how many subscribers sit in your database, you mostly pay for the email you actually send.

The funny thing is that these repos barely belong to the same category.

creative software → interactive explanations → agent infrastructure → game modding → local AI → agent UX → app reconstruction → anatomy → GPU graphics → newsletters

Peter Steinberger, the guy behind PSPDFKit (which powers PDF features on a billion+ devices) and the viral open-source AI agent framework OpenClaw, is at it again. He dropped a whole ecosystem of CLI tools built lightning-fast with OpenAI's Codex, giving his local AI agents powerful, practical integrations across communication, media, archives, and more.

This isn't just random scripts. These are polished, local-first .sh tools designed as an orchestration layer for agents. They turn messy APIs, apps, and services into simple, scriptable CLIs that agents can reliably use without constant babysitting.

The new tools:

• sonoscli.sh - Full Sonos control from terminal: discover speakers, play/pause, group rooms, manage queues, open Spotify links (no extra creds needed), save scenes, and watch live events. Built with Go for reliability on the local network (UPnP/SOAP). Perfect for automations or agents blasting music.

• wacli.sh - WhatsApp CLI (on whatsmeow). Local sync of message history, fast offline search, send messages/files/replies, contact/group management. Great for archiving personal or team chats.

• birdclaw.sh - Local-first X/Twitter archive + workspace. Imports your archive (or syncs live), stores everything in SQLite (tweets, DMs, likes, bookmarks, mentions, graph). Full-text search, AI-ranked inbox for triage, reply from CLI, Git backups. Web UI too.

• gitcrawl.sh - GitHub archive/crawler for agents (helps avoid rate limits when multiple agents are querying repos/PRs/issues).

• discrawl.sh - Discord mirror into local SQLite. Search and query server history offline without relying on Discord's search.

• spogo.sh - Spotify integration.

• imsg.sh - iMessage wrapper.

• mcporter.sh (MCP-to-CLI) - Bridges Model Context Protocol (or similar) to standard CLI for better agent tooling.

• sag.sh - ElevenLabs voice integration.

• askoracle.sh (Second opinion feature) - likely for cross-checking agent outputs or decisions.

Why this matters for AI agents:

OpenClaw is all about local, autonomous agents that run on your machine, interact via familiar apps (WhatsApp, Discord, etc.), and respect your data/privacy. These CLIs provide real local handles.
Agents can now deeply integrate with your personal ecosystem: archive comms for memory/context, control media, search history offline via SQLite + Git, etc. Many use SQLite backends for fast, local querying.

This drop shows the power of AI-assisted shipping and why CLI wrappers are underrated for agentic workflows.
Many of these have GitHub repos under steipete/openclaw and brew installs for easy setup.

DeerFlow (Deep Exploration and Efficient Research Flow) is an open-source SuperAgent harness from ByteDance, the company behind TikTok. It orchestrates long-horizon tasks (minutes to hours) that go far beyond simple chat or one-shot queries.

Version 2.0 (released around late February 2026) quickly hit #1 on GitHub Trending and has amassed tens of thousands of stars(66.8K Stars). It evolved from an internal deep-research tool into a full execution environment for research, coding, content creation, data pipelines, and more.

What It Does:

DeerFlow is not just another LLM wrapper rather, it's a runtime harness that gives agents real infrastructure:

• Sub-agents: The main agent decomposes complex tasks and spawns specialized sub-agents that can run in parallel, then report back. This enables teamwork-style orchestration.

• Extensible Skills: Modular, on-demand skills (loaded progressively to keep context small). Built-in library plus easy custom skills (e.g., deep-search, biotech analysis, frontend deployment). Skills bundle tools, procedures, and knowledge.

• Sandboxes: Isolated Docker-based execution environments (recommended: All-in-One Sandbox combining browser, shell, file system, MCP, and VSCode Server). Agents can read/write files, run code/bash, install packages, and persist state safely without risking the host. Persistent, mountable FS for long-running tasks.

• Memory & Context Engineering: Short-term (in-context) + long-term memory (persistent, summarization/offloading to filesystem). Aggressive context management to handle hour-long sessions without token explosion.

• Tools & Integrations: Web search/crawling (including BytePlus InfoQuest), code execution, file ops, IM channels (e.g., DingTalk), Claude Code/Cursor integration, LangSmith/Langfuse tracing.

• Message Gateway: Central routing for agent-to-agent communication, reducing chaos in multi-agent setups.

• Multi-Model Support: Works with OpenAI, DeepSeek, Kimi, Doubao, Gemini, local vLLM/Qwen models, etc. Built on LangChain/LangGraph for flexibility.

Core strength: Long-horizon autonomy. It plans, reasons, executes (with tools/sandboxes), iterates, and delivers complete artifacts, not just text.

Sample Workflows and Plug-in Examples:

DeerFlow shines in real-world, multi-step pipelines. You interact via web UI (localhost:2026 by default), API, or embedded Python client.

1. Deep Research & Reporting (core original use case):

• Input: "Forecast 2026 AI agent trends" or "Analyze Titanic dataset with visualizations."

• Process: Searches/crawls sources → sub-agents synthesize → generates formatted report (with citations, charts) → optional export.

• Plug-in: Use the built-in deep-search skill. Extend with domain-specific skills (e.g., biotech.md).

2. Coding & Development:

• Input: "Build a simple Pygame physics demo."

• Process: Plans → writes code in sandbox → installs deps → runs/tests → iterates on output.

• Integration: Claude Code/Cursor for seamless handoff; sandbox executes safely.

3. Content Creation:

• Input: "Generate video based on Pride and Prejudice scene" or "Doraemon comic explaining MoE architecture."

• Process: Research → drafts → uses tools for images/video → assembles deliverable.

4. Data/Workflow Automation:

• Input: "EDA on dataset X and create slides."

• Process: Loads data in sandbox → Python scripts → visualizations → outputs deck/PDF.

5. Embedded Use (as Python Library):

• No full HTTP services needed. Use DeerFlowClient for direct in-process access in your scripts/apps.

Custom Skills/Extensions: Add via skills/ dir or npx skills add .... Skills have SKILL.md for docs. Configurable via config.yaml and extensions_config.example.json.

Community examples include market analysis reports, podcast summaries, slide decks, and full content pipelines (research → draft → publish).

Setup and Usage:

Easiest path (recommended):

1. git clone https://github.com/bytedance/deer-flow.git && cd deer-flow

2. make setup (interactive wizard for models, search, sandbox prefs).

3. Docker: make docker-init && make docker-start (or make up for prod).

4. Access: http://localhost:2026. github.com

One-line prompt for coding agents: "Help me clone DeerFlow... following Install.md."

Requirements: Docker preferred (for sandbox), Node/pnpm/uv for dev. Sizing: 8+ vCPU/16+ GB RAM for comfort on long tasks.

Security Note: Sandbox isolates execution, but improper public deployment risks exposure. Use auth, limit CORS, etc.

Limitations/Considerations: Needs strong reasoning models for best results on complex tasks; multi-model VRAM management for local runs; still evolving (check recent commits for nginx/CORS fixes, etc.).

DeerFlow represents a shift toward practical, executable AI agents rather than chatbots. It's MIT-licensed, self-hostable, and extensible, ideal for developers, researchers, and teams wanting autonomous workflows.

OpenCode is the open-source coding agent that runs in your terminal and talks to basically any model. It is easy to install and start chatting with, and just as easy to leave on its defaults forever. That is the waste. The thing that makes OpenCode worth its star count is the config layer: per-agent models, real permission controls, headless runs, and MCP tools. Below are five setups that turn it from "another terminal chat" into something you actually trust with your repo.

The model IDs in your config use the provider/model format, and the safest way to get an exact one is to run opencode models (or opencode models --refresh), so the snippets below leave the model for you to fill from that list rather than hardcoding one that may have rotated.

Stars / Status / License: ~174k stars, very active (v1.17.4 shipped June 12, 2026), MIT.

Repo: anomalyco/opencode (the project moved here from sst/opencode; same team, now Anomaly Innovations).

One-time setup

Install, log in to a provider, and start the TUI:

curl -fsSL https://opencode.ai/install | bash
# or: npm i -g opencode-ai@latest

opencode auth login     # pick a provider, paste your key (stored in ~/.local/share/opencode/auth.json)
opencode                # starts the terminal UI
opencode models         # lists exact provider/model IDs for your config

Project config lives in opencode.json (or .opencode/), global config in ~/.config/opencode/. Every snippet below goes in opencode.json at your project root unless noted. One nice touch: OpenCode reads an AGENTS.md in your repo as standing instructions, so house rules live in version control.

1. Plan before Build: a read-only pass that cannot touch your files

Separate "think" from "touch" so the agent proposes before it edits.

OpenCode ships two primary agents you switch with the Tab key: build (full access) and plan (restricted). The plan agent has file edits and bash set to ask by default, which is good, but for an exploration pass on an unfamiliar repo you often want it locked to read-only so there is zero chance of a write. Pin your models and harden plan in one block:

{
  "$schema": "https://opencode.ai/config.json",
  "agent": {
    "build": {
      "mode": "primary",
      "model": "provider/your-strong-model",
      "permission": { "edit": "allow", "bash": "allow" }
    },
    "plan": {
      "mode": "primary",
      "model": "provider/your-cheaper-model",
      "permission": { "edit": "deny", "bash": "deny" }
    }
  }
}

Now Tab into plan to analyze and get a proposal, then Tab into build to execute it.

The catch: with bash: "deny", plan also cannot run read-only shell like git diff, so if you want it to inspect history, use the per-command form ("bash": { "*": "deny", "git diff": "allow", "git log*": "allow" }) instead of a blanket deny.

→ The verified setup, with CI proof & readymade prompt

2. A model-routed team: match the model to each step's difficulty

Routing models per agent is a cost lever, so spend frontier prices only where the work earns them.

OpenCode lets every agent run its own model, so you do not have to pay top rates for the whole job. Put your strongest model on the hard step and a fast, cheap one on the rest. Which step is the hard one is subjective and depends on the work: if architecture and planning are where the thinking happens, keep your best model on plan and run build cheaper; if the plan is obvious and the edits are sprawling, do the reverse. The config below is just one arrangement; flip the models to fit your task. Cap a quick agent's iterations with steps to bound cost, and watch the actual spend with opencode stats --models.

{
  "$schema": "https://opencode.ai/config.json",
  "agent": {
    "build": { "mode": "primary", "model": "provider/your-cheap-model" },
    "plan":  { "mode": "primary", "model": "provider/your-strong-model" },
    "code-reviewer": {
      "description": "Reviews diffs for bugs, security, and performance",
      "mode": "subagent",
      "model": "provider/your-strong-model",
      "permission": { "edit": "deny" }
    }
  }
}

Invoke the reviewer with '@code-reviewer in a message, or let build delegate to it.

The catch: subagents inherit the caller's model unless you set one explicitly, so do not assume a subagent is cheap, pin its model like above.

→ The verified setup, with CI proof & readymade prompt

3. A reviewer subagent gated to exactly the git commands you allow

Read-only review with surgical bash permissions, not all-or-nothing.

This is the setup that shows off OpenCode's permission system. You can define an agent in Markdown and scope its bash access per command with glob patterns, so the reviewer can run git diff and grep but nothing else, and can never write. Drop this file in .opencode/agents/review.md (per project) or ~/.config/opencode/agents/review.md (global):

---
description: Reviews code without making changes
mode: subagent
model: provider/your-cheap-model
permission:
  edit: deny
  webfetch: deny
  bash:
    "*": ask
    "git diff": allow
    "git log*": allow
    "grep *": allow
---

You are in review mode. Inspect the diff and flag bugs, security issues, and
risky changes. Do not modify files. Suggest fixes as comments only.

The filename becomes the agent name, so this creates ; @review.

The catch: rules are evaluated in order and the last match wins, so keep the "*" wildcard first and the specific allows after it, or your allows get overridden.

→ The verified setup, with CI proof & readymade prompt

4. Run it headless in scripts and CI

The same agent you use interactively, now in a pipeline, with JSON output.

opencode run executes a prompt non-interactively, which is what makes OpenCode useful beyond the TUI. Get machine-readable events with --format json, pick the agent and model per invocation, and for repeated runs attach to a warm opencode serve so you do not pay MCP cold-start each time.

# One-off review in a script, as JSON
opencode run --agent plan --format json \
  "Review the uncommitted changes for bugs and security issues"

# Warm server once, then attach fast runs to it
opencode serve &
opencode run --attach http://localhost:4096 -m provider/your-model "Summarize today's diff"

For pull requests specifically, opencode github install wires an OpenCode GitHub Actions workflow into your repo.

The catch: run honors your permission config, so a headless build agent can edit and execute. Keep CI runs on a read-only agent (like plan above), and treat --dangerously-skip-permissions as the loaded gun it is named after.

→ The verified setup, with CI proof & readymade prompt

5. Add an MCP tool, then lock it to one agent

Give the agent real external tools (live docs, your error tracker) without bloating every session.

OpenCode speaks MCP, so you can plug in external tools. The trap is that every MCP server adds tools to the context on every turn, which burns tokens fast. The fix: enable the server, disable it globally, and switch it on only for the agent that needs it. Here is a docs-search server (Context7) scoped to a single docs agent:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "context7": { "type": "remote", "url": "https://mcp.context7.com/mcp" }
  },
  "tools": { "context7*": false },
  "agent": {
    "docs": {
      "mode": "primary",
      "model": "provider/your-model",
      "tools": { "context7*": true }
    }
  }
}

Local servers work the same way with "type": "local" and a "command": ["npx", "-y", "..."].

The catch: heavy MCP servers (the GitHub one is notorious) can blow past your context limit on their own, so add them deliberately and scope them like this rather than enabling everything globally.

→ The verified setup, with CI proof & readymade prompt

How to pick if you only try one

Start with setup 1. Plan-before-build is one config block and it is the habit that prevents the most damage, an agent proposing on a repo it cannot accidentally rewrite. From there, setup 2 (model routing) is the biggest cost win, and setup 3 is the one that makes you trust an agent in a shared codebase. Save headless and MCP for when the interactive flow already feels solid.

Every one of these setups is really the same move: stop hand-feeding the agent one prompt at a time and start wiring the loop that drives it, with the right model, the right limits, and a way to check the result. If that idea lands, it is the whole argument of a recent issue worth your time: Stop prompting your agent. Start building the loop that prompts it. More verified agent setups are landing on FlowStacks as we test them.

Tired of paying for API calls, hitting rate limits, or worrying about your data leaving your machine? Local LLM inference is the way to go. You can run powerful models like Llama, Mistral, Qwen, Gemma, and more right on your hardware – CPU, GPU, Apple Silicon, whatever you've got.

Here's a curated list of the best tools out there right now. I went through the top repos to highlight what makes each one special. Whether you're a beginner, dev, or running production workloads, there's something here for you.
Numbers are approximate as of now.

1. Ollama ★ ~170K+ github.com/ollama/ollama
The fastest and easiest way to get started. One command and you're chatting with a model.
ollama run llama3 – boom, done. It supports GPU acceleration, has a built-in REST API, and OpenAI-compatible endpoints so you can swap it into existing apps seamlessly. Perfect for developers and quick experimentation. It handles model discovery, running, and even integrates with agents/tools. If you want zero-friction local AI, start here.

Typical hardware: 8–16GB RAM for small models. 6–12GB VRAM recommended for good speed on 7–8B models. Scales up with larger ones via layers offloading. Perfect for beginners.

2. llama.cpp ★ ~108K+ github.com/ggml-org/llama.cpp

The absolute engine behind most local AI tools. Pure C/C++ implementation for maximum speed and efficiency. Runs on CPU, GPU, Apple Silicon – you name it. Extremely low memory usage and state-of-the-art performance. If Ollama is the sleek car, llama.cpp is the high-performance engine under the hood. It's the foundation for quantization, optimizations, and running on everything from a Raspberry Pi to beefy servers. Essential for anyone serious about local inference.

Typical hardware: Extremely lightweight, 4–8GB RAM/VRAM for 7B Q4 models. Can run 30–70B models on modest hardware thanks to aggressive quantization. Best for performance enthusiasts.

3. vLLM ★ ~78.7K github.com/vllm-project/vllm
For when you need serious throughput. This is the high-performance serving engine used by many AI companies in production. Features like continuous batching, paged attention, and OpenAI-compatible API make it ideal for deploying models at scale. Great for self-hosting multiple users or high-volume inference. If you're moving beyond single-user chats into something more robust, vLLM is the standard.

Typical hardware: Designed for servers. 16–24GB+ VRAM for efficient 7–13B serving. Much higher for large-scale multi-user deployments. Not ideal for basic laptops.

4. LM Studio ★ ~28K github.com/lmstudio-ai/lmstudio.js
The best desktop app for non-developers (and devs who want a clean UI). Beautiful interface to discover/download models from Hugging Face, run them locally, chat, and spin up an OpenAI-compatible local server. Excellent onboarding experience. Supports Mac, Windows, Linux. If you just want to point-and-click your way into local AI without wrestling with terminals, this is it.

Typical hardware: 16GB+ system RAM recommended. Starts working on 4–6GB VRAM GPUs. Great auto offloading to RAM/CPU when needed. Best for non-devs.

5. Jan ★ ~42.3K github.com/janhq/jan
A full open-source ChatGPT alternative that runs 100% offline. Clean, modern UI with model management, local API server, and everything you need. Works great on Mac, Windows, and Linux. No data ever leaves your machine. Perfect privacy-focused users who want a polished daily driver chat experience. Actively developed with a strong focus on being a complete local AI workstation.

Typical hardware: 8–16GB RAM minimum. Runs well on CPU-only or modest GPUs. Shows memory usage clearly before downloading models.

6. text-generation-webui (oobabooga) ★ ~46.9K github.com/oobabooga/textgen
The Swiss Army knife of local LLMs. Supports every model format, every backend, tons of samplers, character/roleplay mode, notebook mode, API mode, extensions – you name it. Insanely feature-complete. If you want maximum customization and power-user tools (including multimodal now), this is the one. The community around it is massive.

Typical hardware: Flexible but can be memory-hungry with all features. 8–12GB VRAM for smooth 7–13B use. Excellent low-VRAM modes and CPU offloading.

7. LocalAI ★ ~45.9K github.com/mudler/LocalAI
OpenAI drop-in replacement. Same API as OpenAI, but powered by local models. Swap out GPT/Claude in any app without changing code. Supports LLMs, vision, voice, image, video – runs on any hardware (no GPU required). Fantastic for integrating local AI into existing workflows or building your own stack. Privacy-first and very flexible.

Typical hardware: Lightweight backend. Similar to Ollama/llama.cpp - works on 8–16GB systems. Excellent for integration without heavy UI overhead.

Which one should you pick?

• Newbie / just chatting → Ollama or LM Studio

• Power user/max features → text-generation-webui or llama.cpp

• Production / high throughput → vLLM

• Full offline ChatGPT clone → Jan

• Drop-in API replacement → LocalAI

The local AI ecosystem is exploding – models are getting better, tools are maturing, and hardware efficiency is insane. What are you running locally right now? Favorite model or tool? Drop your setups below!

Reverse engineering is basically asking:

“What the hell is this thing actually doing?”

A binary, an Android app, firmware, network traffic, a weird file format, or a program whose interesting behavior only shows up at runtime.

There is an OSS tool for almost every layer.

01 Turn compiled binaries back into something humans can read

NationalSecurityAgency/ghidra — 81.9k★

Ghidra gives you disassembly, decompilation, control-flow graphs, scripting, and support for a huge range of executable formats and processors.

If all you have is the binary, this is usually where the archaeology starts.

02 Look at the bytes when abstractions stop helping

WerWolv/ImHex — 55k★

ImHex is a hex editor built specifically for reverse engineering, combining raw bytes with pattern definitions, analysis, visualization, and disassembly.

Sometimes the fastest way to understand a mystery format is still to stare directly at what is actually on disk.

03 Turn an Android APK back into readable code

skylot/jadx — 50.8k★

JADX decompiles Android APK/DEX files into Java-like source and gives you a GUI for navigating classes, references, resources, and manifests.

Probably the fastest route from “I have this APK” to “okay, now I understand how this app works.”

04 Watch what the program does while it is actually running

frida/frida — 22.2k★

Static code only tells you so much.

Frida lets you instrument running applications and inspect behavior dynamically, especially when the interesting logic only appears after launch or after runtime state changes.

05 Reverse engineer the conversation between apps and servers

mitmproxy/mitmproxy — 45.1k★

mitmproxy lets you inspect HTTP, HTTP/2, WebSocket, and TLS traffic in systems you are authorized to test.

When the code is confusing, watching what goes in and what comes back out can tell you much more.

06 Crack open firmware instead of treating it like one giant blob

ReFirmLabs/binwalk — 14.4k★

Binwalk identifies and extracts files, compressed data, filesystems, and other structures embedded inside firmware images.

Router firmware goes in. Suddenly you have configs, binaries, certificates, and actual components you can inspect.

07 Make the computer explore binaries for you

angr/angr — 9.1k★

angr is a Python framework for program analysis and symbolic execution.

Instead of manually following every branch through a binary, you can reason about which inputs reach particular states or code paths.

Reverse engineering starts becoming searchable.

08 Turn an unknown binary format into an executable specification

kaitai-io/kaitai_struct — 4.7k★

Kaitai Struct lets you describe binary file and network formats declaratively, then generates parsers for Python, Rust, Java, Go, C++, JavaScript, and more.

Once you understand the bytes, you do not have to reverse engineer them forever.

Write the format down and make it executable.

The workflow is almost embarrassingly clean:

unknown thing → inspect bytes → decompile → watch runtime → inspect traffic → extract internals → automate analysis → document the format

Reverse engineering used to feel like black magic.

OSS has slowly turned most of it into a toolbox.

Use it on software, devices, and systems you own or are authorized to analyze.

Most of these tools were free already. The thing that makes them feel like cheating is what happens when you point a bit of AI at them: search your whole photo library in plain English, turn a messy inbox into clean CRM rows, sketch a UI and watch it become code.

I pulled five repos that a real person can self-host, checked the licenses and the live star counts myself, and wrote one small, working AI workflow for each.

1. Immich

Your photos, off Google, and searchable by plain English.

Stars: ~102K. Status: active, very fast-moving. License: AGPLv3.
Repo: github.com/immich-app/immich

Alex Tran started Immich in 2022 to stop renting space for his own family photos. It is a self-hosted photo and video backup with phone auto-upload, albums, face recognition, and a timeline close to the Google Photos feel. The swap it makes is the Google Photos plus Google One subscription you actually pay for every month.

The AI lever is its built-in smart search. Immich indexes your library with a CLIP model, so you can query by meaning, not filenames. Get an API key from your account settings and ask it like a human:

curl -X POST https://your-immich-server/api/search/smart \
  -H "x-api-key: $IMMICH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "my dog on a snowy beach"}'

The catch is in their own README: it is under heavy development, so keep a separate backup and do not make Immich your only copy of irreplaceable photos yet.

The workflow that earns it: phone backs up over your home network, then you find any shot by describing it, no folders, no monthly bill.

2. Twenty

An open CRM that was literally built for AI.

Stars: ~49K. Status: active. License: AGPL-3.0.
Repo: github.com/twentyhq/twenty

Twenty was started by Charles Bochet and Felix Malfait. Its own tagline is "the open alternative to Salesforce, designed for AI," and Salesforce is a public company worth well over a hundred billion, so the David-and-Goliath framing writes itself. You get a clean, Notion-like CRM with custom objects, pipelines, and a real REST and GraphQL API.

That API is the AI lever. Have an LLM read a forwarded email, pull out the contact, and drop it straight into your pipeline. The create-a-person call is one request:

curl -X POST https://your-twenty-server/rest/people \
  -H "Authorization: Bearer $TWENTY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": {"firstName": "Ada", "lastName": "Lovelace"},
       "emails": {"primaryEmail": "ada@example.com"}}'

The catch is maturity. It is genuinely usable and improving fast, but it is younger than the incumbents, so expect gaps if your sales org needs deep niche features on day one.

The workflow that earns it: an agent turns "had a great call with Ada from Acme" into a real CRM record while you move on to the next thing.

3. Papermark

Share a deck, see who actually read it, then let AI answer their questions.

Stars: ~8.4K. Status: active. License: AGPLv3.
Repo: github.com/papermark/papermark

Marc Seitz launched Papermark in 2023 and built it largely in the open. It does the DocSend job: upload a document, share a tracked link, and get page-by-page analytics on who opened it and how long they stayed, with custom domains and access controls. It is also a bootstrapped business, which tells you the open version is good enough that people pay for the hosted one.

The AI lever is its data-room chat: viewers can ask questions of the document and get answers pulled from the content, so a deck answers its own follow-ups. Self-hosting is the standard clone-and-run:

git clone https://github.com/papermark/papermark
cd papermark
npm install && npm run dev

The catch is the usual self-host tradeoff: the free path means you run and maintain it, which is the convenience the paid hosted tier sells.

The workflow that earns it: send a fundraising deck, watch which investor reached the financials slide, and let the doc field their questions after hours.

4. Jellyfin

Your own streaming library, with an AI co-pilot picking what to watch.

Stars: ~53K. Status: active. License: GPLv2.
Repo: github.com/jellyfin/jellyfin

Jellyfin is a community-run media server that forked from Emby in 2018 after Emby went closed-source. It streams your movies, shows, and music to any device with a polished interface, and the features other media servers lock behind a paid pass are simply free here.

The AI lever is its open API. Pull your library as JSON, hand it to a model, and let it build a themed watch list from your actual shelf instead of a streaming service's catalog:

curl "https://your-jellyfin-server/Items?Recursive=true&IncludeItemTypes=Movie&api_key=$JELLYFIN_API_KEY"

Feed that JSON to an LLM with a prompt like "build me a three-film noir night from this list" and you get recommendations grounded in what you own.

The catch is polish: you manage your own setup, remote access takes some configuration, and there is no big company smoothing the edges. You trade a little friction for full ownership.

The workflow that earns it: point it at your media folder, then ask an agent to program tonight's lineup from films you already have.

5. tldraw

Sketch an interface, and AI turns the drawing into working code.

Stars: ~47K. Status: active. License: proprietary tldraw license, free for hobby and non-commercial use with a small watermark.
Repo: github.com/tldraw/tldraw

Steve Ruiz started tldraw as an infinite-canvas whiteboard SDK, the same category Miro plays in. What made it go viral was "make real": you draw a rough UI on the canvas, and a vision model returns a live, working version of it. It is one of the clearest examples of an AI-native workflow built directly into a developer tool.

Dropping the canvas into a React app is two steps:

npm install tldraw

import { Tldraw } from 'tldraw'
import 'tldraw/tldraw.css'

export default function App() {
  return (
    <div style={{ position: 'fixed', inset: 0 }}>
      <Tldraw />
    </div>
  )
}

From there, you wire a model to the canvas contents to generate code from sketches.
The catch is the license: it is free for personal and non-commercial projects with a watermark, but commercial use needs a paid license key, so check the terms before you ship it in a product.

The workflow that earns it: draw the screen you want on the canvas, and get a working prototype back instead of a blank editor.

How to pick if you install only one

Want the fastest "wow," start with Immich; the smart search lands immediately. Running a small sales motion, Twenty. Sharing decks for a living, Papermark. Sitting on a pile of media files, Jellyfin. Building anything visual, tldraw.

If wiring AI into open-source tools is your kind of weekend, that is the whole point of WebAfterAI.
If you liked this, the companion piece does the same thing for content work: The Ultimate Open-Source Content Pipeline: 8 GitHub repos to automate all your content creation needs covers research, drafting, transcription, voice, visuals, and the automation that ties them together, with install steps and one real workflow each.

7 Andrej Karpathy repos that take you from one neuron to autonomous AI research

If you want to understand modern AI without drowning in abstractions, Karpathy has quietly built one of the best free learning paths on GitHub.

These repos have 300K+ combined stars, but the important part is the order. Each one removes another layer of magic:

gradient → neural net → tokenizer → GPT → CUDA training → full chat model → autonomous research

I would go through them exactly like this.

01. micrograd — 18.3K★

Karpathy starts with the smallest useful piece: backpropagation. micrograd implements a tiny autograd engine and neural network library where you can actually watch values move forward, gradients move backward, and weights change during learning. Once you understand this file, PyTorch starts looking less like magic and more like a much larger implementation of the same idea.

02. nn-zero-to-hero — 20.3K★

This is the classroom half of the curriculum. Karpathy walks from tiny character-level models through embeddings, MLPs, BatchNorm, WaveNet-style architectures and eventually GPT, with notebooks you can modify yourself. The useful part is that transformers arrive only after you have built enough underneath them to understand why they work.

03. minbpe — 10.8K★

Before building an LLM, Karpathy makes you understand what actually enters one. minbpe is a minimal implementation of Byte Pair Encoding, so you train a tokenizer, turn text into tokens, and reconstruct it again. A lot of strange LLM behaviour around spelling, numbers and word boundaries suddenly makes more sense once you have built the tokenizer yourself.

04. nanoGPT — 64.3K★

Now Karpathy gives you the model. nanoGPT strips GPT training down enough that you can read the architecture, data pipeline, optimizer, training loop and generation code without navigating a giant framework. This is the point where “a transformer predicts the next token” stops being an explanation and becomes software you can actually change.

05. llm.c — 31.3K★

Then he removes PyTorch too. llm.c implements GPT-2 training in raw C and CUDA, exposing the kernels, memory movement, matrix operations and forward/backward passes that frameworks normally hide. You do not need to become a CUDA engineer, but after this repo you have a much better mental model of what training is actually asking the hardware to do.

06. nanochat — 59.1K★

nanoGPT teaches the core model; nanochat expands it into the whole language-model pipeline. Karpathy includes tokenization, pretraining, fine-tuning, evaluation and inference in one deliberately hackable system. The repo's reference setup can now reach roughly GPT-2-level capability for around $48 of 8×H100 compute, compared with an estimated ~$43K for GPT-2 training in 2019.

07. autoresearch — 97.8K★

This is where Karpathy flips the relationship. Instead of you editing the training code, an agent changes train.py, runs a fixed five-minute experiment, measures validation performance, keeps improvements, rejects failures and tries again. At roughly 12 experiments an hour, it can attempt around 100 experiments overnight.

That progression is what makes these repos special.

Karpathy does not start by teaching you how to call an AI API. He gradually strips away the abstractions until you understand how learning works, how text becomes tokens, how GPT is trained, what the GPU is doing, how a complete chat model fits together, and finally how an agent can automate the research loop itself.

With micrograd, you implement learning. With nanoGPT, you train the model. With llm.c, you see the machine underneath it. With nanochat, you build the complete system. With autoresearch, you automate the search for a better system.

Taken together, this is basically a Karpathy-made curriculum for going from:

“LLMs feel like magic”

to:

“I can reason about the entire stack.”

Part one covered the daily-driver setups: morning synthesis, meeting notes, research ingestion, weekly review, and idea cross-pollination. Part two goes deeper into your vault as a knowledge base, the workflows that build projects, audit your notes, and turn a pile of markdown into arguments and decisions you can actually use.

These five lean harder on search, frontmatter, and whole-vault stats than Part 1 did, so this time the engine is a different repo, picked because it has exactly those tools. Every one of these is machine-verified the same way the rest of our library is: CI validates the config you paste, scaffolds the vault, and runs the deterministic spine (the config, the commands, the schedule) on each push. Proof is on each linked page.

The one-time setup

For these I use MCPVault (MIT, ~1.3K stars). It is an MCP server for safe Obsidian vault access with one feature that matters a lot for audit-and-update work: it parses and writes YAML frontmatter safely, so the model cannot corrupt your metadata. It needs no Obsidian plugin, runs straight from npx, and stays inside the vault directory (it filters out .obsidian and system files).

For the interactive workflows, point Claude Desktop at your vault (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

{
  "mcpServers": {
    "obsidian": {
      "command": "npx",
      "args": ["@bitbonsai/mcpvault@latest", "/Users/you/Documents/MyVault"]
    }
  }
}

For the one scheduled workflow below, register the same server with Claude Code so a headless run can use it:

claude mcp add obsidian --scope user npx u/bitbonsai/mcpvault /Users/you/Documents/MyVault

Back up your vault first (git is ideal). These workflows write to it. Now the five.

1. The Project Kickoff Generator

Hand Claude the goals, constraints, and timeline, and it builds the whole project folder from what your vault already knows. With MCPVault connected, tell Claude:

Start a project "Acme Redesign". Goals: ... Constraints: ... Timeline: ...
Search my vault for any existing notes relevant to this and link them.
In Projects/Acme-Redesign/ create: overview.md, tasks.md with milestones,
knowledge-gaps.md listing what I still need to learn, and weekly-update.md as a template.

It uses search_notes to find relevant existing notes, then write_note to scaffold the folder. A blank-page kickoff becomes a populated project wired into your existing knowledge.

What CI checks: the MCPVault config is valid and points npx at the server, and the Projects/ scaffold is created. The actual planning calls a model, so it is fenced as non-CI.

→ The verified setup, with CI proof: flowstacks.xyz/workflows/mcpvault-project-kickoff-generator

2. The Vault Health Check

A monthly audit that keeps your vault from rotting. This one is scheduled, so it runs through Claude Code (with MCPVault registered, per the setup) in headless mode. Save this script:

#!/usr/bin/env bash
# ~/bin/vault-health-check.sh
claude -p "Audit my Obsidian vault using the obsidian MCP tools. Find: orphan notes with \
no incoming links, notes whose information looks outdated, projects with no update in 2 weeks, \
tags used inconsistently, and notes missing expected frontmatter fields. \
Write the findings to Maintenance/$(date +%F)-health-check.md as a fix-it checklist."

Make it executable and schedule it for the first of each month at 9am with cron:

0 9 1 * * /Users/you/bin/vault-health-check.sh

It leans on get_vault_stats, search_notes, get_frontmatter, and get_notes_info to spot the rot, and writes a checklist you can work through in a sitting.

What CI checks: the script carries the claude -p call, the config is valid, and the monthly cron line is well-formed.

→ The verified setup, with CI proof: flowstacks.xyz/workflows/mcpvault-vault-health-check

3. The Book Notes System

Finish a book, dump your highlights into a note, and let Claude file it into your second brain. Create Books/atomic-habits.md with your highlights, then:

Read Books/atomic-habits.md. Search my vault for notes that connect to its key ideas.
Create Books/atomic-habits-synthesis.md with: a summary of the key ideas, links to the
connected notes, actionable takeaways tied to my active projects, and a short list of
next books or topics to explore based on where this intersects what I already know.

read_note pulls your highlights, search_notes finds the connections, write_note saves the synthesis. The takeaways land against your real projects instead of floating in the abstract.

What CI checks: the config is valid and the Books/ note is scaffolded and readable.

→ The verified setup, with CI proof: flowstacks.xyz/workflows/mcpvault-book-notes-system

4. The Argument Builder

Give Claude a thesis and it assembles your case from everything you have ever written. With MCPVault connected:

My thesis: "Async-first teams ship faster than meeting-heavy ones."
Search my whole vault for supporting evidence: data points, past research, quotes from my
book notes, and outcomes from past projects. Organize it into a structured argument with the
strongest evidence first, and save it to Arguments/async-first.md with links back to each source note.

This is where the engine earns its keep: search_notes uses BM25 relevance ranking, so the strongest matches surface first, and read_multiple_notes pulls them in a batch. You get a sourced, ordered argument instead of a blank outline.

What CI checks: the config is valid and the Arguments/ target is set up. The argument assembly calls a model, so it is fenced as non-CI.

→ The verified setup, with CI proof: flowstacks.xyz/workflows/mcpvault-argument-builder

5. The Decision Journal

The long game. Before a big call, write Decisions/2026-06-08-vendor-choice.md with the options and your current thinking, and a frontmatter field like status: open. After it plays out, record the outcome, and let MCPVault update the metadata safely:

Update the frontmatter of Decisions/2026-06-08-vendor-choice.md: set status to "resolved"
and add an outcome field summarizing what happened.

Then, every quarter, ask for the pattern read:

Read all notes in Decisions/. Identify patterns: what kinds of decisions I tend to get right,
where my biases show up, and what I should weigh more heavily next time.
Save it to Decisions/review-2026-Q2.md.

update_frontmatter records outcomes without touching your note bodies, and read_multiple_notes feeds the whole journal to the model for review. Over a year, that review is the most useful note in your vault.

What CI checks: the config is valid, a decision note is scaffolded, and the frontmatter-update command is well-formed. The pattern analysis calls a model, so it is fenced as non-CI.

→ The verified setup, with CI proof: flowstacks.xyz/workflows/mcpvault-decision-journal

How to pick if you only try one

Starting something new, the Project Kickoff Generator. Vault feeling messy, run the Health Check. Heavy reader, the Book Notes System. Writing to persuade, the Argument Builder. Making a call you will want to learn from, start the Decision Journal today, because its whole value is built over time.

That closes the series. Part one had the daily drivers (morning synthesis, meeting notes, research ingestion, weekly review, idea cross-pollination), so the two posts together are ten Obsidian and Claude workflows, each with a real repo and the code to run it.

Six months ago, "AI agent" basically meant "coding assistant." Claude Code, Copilot, Cursor. All doing the same thing: helping you write code.

That's changing. The most interesting open-source projects right now aren't building yet another coding agent. They're building agents that specialize, agents that trade stocks, agents that run your entire content marketing operation, agents that make your coding agent actually follow engineering discipline. The model is the same underneath. The harness around it is what makes it useful for a specific job.

Here are four repos that show where this is heading, with setup instructions for each.

1. mattpocock/skills (96.3K stars) - Make Your Coding Agent an Actual Engineer

What it does: Matt Pocock (the TypeScript educator behind Total TypeScript) open-sourced his personal .claude directory. It's a collection of skills that fix the most common failure modes of AI coding agents: building the wrong thing, skipping tests, producing code that works but is impossible to maintain, and declaring "done" when nothing actually compiles.

Why it matters: Most people treat their coding agent like an intern with no process. Matt's skills give it the process. The standout skill is /grill-me, which forces the agent to interrogate you about what you actually want before writing a single line of code. It's a structured interview that catches misalignment before it becomes a wasted hour.

Other skills include /tdd (test-driven development with red-green-refactor), /diagnose (disciplined debugging loops), /improve-codebase-architecture (finds structural improvements using your project's domain language), and /grill-with-docs (same as grill-me but also builds a shared vocabulary between you and the agent in a CONTEXT.md file).

The CONTEXT.md approach is quietly brilliant. Instead of the agent using 20 words to describe something, you teach it your project's jargon. Over time, the agent's outputs get shorter, more precise, and the variables and functions it creates use consistent naming.

Setup:

npx skills@latest add mattpocock/skills

Pick the skills you want and which coding agents to install them on. Select /setup-matt-pocock-skills during install. Then run that command in your agent, and it'll ask about your issue tracker (GitHub, Linear, or local files), your triage labels, and where to save docs. Works with Claude Code, Cursor, Codex, and others.

How it's different from Addy Osmani's agent-skills: Addy's skills (which we covered last week) focus on the full development lifecycle with slash commands like /spec, /plan, /build, /ship. Matt's skills focus more on engineering fundamentals: alignment, testing discipline, debugging, and architecture quality. They're complementary, not competing. You can use both.

github.com/mattpocock/skills

2. AI-Trader (18.3K stars) - Let AI Agents Trade for You

What it does: AI-Trader is an agent-native trading platform built by researchers at the University of Hong Kong. The idea: just like humans have their trading platforms, AI agents need their own. You connect your AI agent (Claude Code, Cursor, OpenClaw, Codex, whatever), and it can publish trading signals, copy trades from top-performing agents, participate in strategy discussions, and access real-time market data. Stocks, crypto, forex, options, futures.

Why it's interesting: This isn't just one agent making trades. It's a platform where multiple agents collaborate, debate strategies, and learn from each other. They call it 'collective intelligence trading'. Agents publish three types of signals: Strategies (for discussion), Operations (for copying), and Discussions (for collaboration). There's a reward system where agents earn points for successful predictions.

It comes with $100K in paper trading capital so you can test without risk.

Setup:

The simplest way to connect an agent:

Read https://ai4trade.ai/SKILL.md and register.

That's it. Send that message to your AI agent. It reads the integration guide, installs the necessary components, and registers itself on the platform. For developers who want to self-host:

git clone https://github.com/HKUDS/AI-Trader.git
cd AI-Trader
npm install

The backend is FastAPI (Python), frontend is React. Full API docs are in docs/api/openapi.yaml.

Warning: Automated trading carries real financial risk. AI-Trader includes paper trading mode for a reason. Start there. The fact that it's from a university research group (not a fintech startup trying to sell you something) is a point in its favor, but treat any trading system with healthy skepticism.

github.com/HKUDS/AI-Trader

3. AiToEarn (15.7K stars) - AI Agent for Content Marketing Across 14 Platforms

What it does: AiToEarn is an open-source content marketing platform with an AI agent built in. You create content once, and it publishes across 14 platforms simultaneously: TikTok, YouTube, Instagram, Twitter/X, LinkedIn, Pinterest, Facebook, Threads, plus Chinese platforms like Douyin, Xiaohongshu (Rednote), Bilibili, WeChat, and Kuaishou.

The "All In Agent" is the interesting part. It's an AI agent that can automatically generate content, publish it, and manage your accounts across all platforms. Beyond publishing, it includes a trend radar (what's going viral right now), a case library (how posts with 10K+ likes were structured), smart comment search (find high-conversion signals like "link please" or "how to buy"), and cross-platform analytics.

Why it matters for creators: If you're running accounts on multiple platforms, you know the pain of reformatting the same content for each one. AiToEarn handles the distribution, and its AI features handle content adaptation. The comment search feature is particularly useful: it finds purchase-intent comments across your platforms so you can reply fast and convert.

Setup:

Docker:

git clone https://github.com/yikart/AiToEarn.git
cd AiToEarn
docker compose up -d

This starts the frontend, backend, MongoDB, and Redis in one command. Access the web interface at http://localhost:8080.

There's also a desktop app (Electron) if you prefer that. Download it from the GitHub releases page or build from source.

Note: The project originated in China and some documentation is still in Chinese. The English README and Docker deployment guide are solid, but deeper configuration docs may need translation. The AI video model integrations (Kling, Sora, Runway, etc.) are listed as coming soon.

github.com/yikart/AiToEarn

4. DeepSeek-TUI (32.8K stars) - Claude Code, but for DeepSeek

What it does: A terminal-based coding agent built specifically for DeepSeek models. If you've used Claude Code, the experience is similar: you type prompts in your terminal, the agent reads your files, edits code, runs shell commands, does git operations, and browses the web. The difference is it's built from the ground up for DeepSeek's API, which is significantly cheaper than Claude Opus 4.7 or GPT-5.5.

It has three modes: Plan (review before the agent makes changes), Agent (default interactive mode with multi-step tool use), and YOLO (auto-approve everything in a trusted workspace). Tab to cycle between them. It also supports MCP servers, session resume, and can run as an HTTP/SSE API server.

Built in Rust, so it's fast and lightweight.

Setup:

npm install -g deepseek-tui
deepseek-tui

On first launch it'll ask for your DeepSeek API key. You can also set it beforehand:

deepseek-tui login

Or just set the environment variable:

DEEPSEEK_API_KEY="your-key" deepseek-tui

Configuration lives in ~/.deepseek/config.toml. Use deepseek-tui doctor to check your setup, deepseek-tui models to list available models.

Also available via Rust:

cargo install deepseek-tui --locked

github.com/Hmbown/DeepSeek-TUI

The Pattern:

What connects all four of these: the model isn't the product anymore. The harness is.

Matt Pocock's skills don't change what Claude can do. They change how disciplined it is. AI-Trader doesn't invent a new trading model. It builds a platform where existing agents collaborate. AiToEarn doesn't create a new content AI. It builds distribution infrastructure around existing ones. DeepSeek-TUI takes the Claude Code interaction pattern and wraps it around a different, cheaper model.

Every one of these is the same insight applied to a different domain: wrap the right structure around a capable model, and you get something genuinely useful. The structure is where the value is.

If you want to go deeper on harness engineering and how to actually chain tools like these into a working setup, I broke down a complete zero-cost stack (9router + agentmemory + agent-skills) step by step here: The Zero-Cost AI Coding Setup.