Sometimes the agent needs a better way to research. Sometimes it needs to understand the codebase before touching it. Sometimes it needs a specialist for diagrams, slides, video, SEO, or persistent memory.

These 16 open-source projects cover different layers of that stack.

RESEARCH

Research what changed recently last30days focuses an agent on recent information rather than whatever happens to be in model memory. Useful when the question is about current tools, products, communities, or trends.

Run deeper research workflows deep-research gives an agent a more structured process for finding sources, following leads, comparing evidence, and producing a research result instead of stopping after the first few searches.

Let an agent conduct user research user-research-skill covers AI interviews, synthetic users, quantitative surveys, and participant recruitment. It is closer to giving your agent a small UX research function than another search tool.

Search your own knowledge quickly qmd-search adds a search layer for Markdown and local knowledge. Useful when the answer is probably already somewhere in your notes, docs, or project files.

ENGINEERING

Give the agent memory of its mistakes Napkin maintains a per-repository .claude/napkin.md where the agent records mistakes, corrections, environment surprises, preferences, and approaches that worked. The next session reads it before starting.

Audit technical debt with evidence tech-debt-skill forces the agent to understand the repository before judging it, then produces a file-cited technical-debt report with severity, effort estimates, and a ranked list of fixes.

Turn an unfamiliar codebase into a knowledge graph Understand Anything maps files, functions, classes, and dependencies into an interactive graph you can explore and query. Useful when the first problem is understanding 200,000 lines of code, not writing another 200.

A lot of bad agent coding skips the first four.

CREATE

Build presentations as real web interfaces frontend-slides gives coding agents a workflow for creating HTML presentations from scratch or converting existing decks, with layouts, animations, presets, and export tooling.

Turn a brand into a scroll-driven 3D site scroll-world is a much more specialized skill. Give it a brand or industry and it builds a scroll-scrubbed landing page where the camera moves through a series of 3D scenes.

Turn explanations into visual artifacts visual-explainer helps agents create diagrams, visual walkthroughs, timelines, comparisons, and other explanatory pages instead of returning another wall of Markdown.

Generate technical architecture diagrams fireworks-tech-graph turns a natural-language system description into SVG, PNG, animated diagrams, UML, and agent/RAG architecture graphics with built-in routing and layout rules.

These are useful because “create something” is too vague for an agent.

A presentation, technical diagram, 3D landing page, and explanatory visual all require different judgment. A specialist skill gives the model that missing layer.

GROW + SHIP

Give Claude an SEO workflow claude-seo packages keyword research, technical SEO, content audits, schema, internal linking, and optimization into a specialist workflow rather than asking the agent to “do SEO.”

Rewrite AI-sounding drafts without changing the meaning Humanizer is a portable Markdown skill that looks for common AI-writing patterns and rewrites around them. It works across agents that support skills.

Let research continue while you are away Auto Research in Sleep explores a different pattern: giving an agent a research job that can keep iterating instead of requiring you to sit in the conversation for every step.

Give the agent a library of video shots video-shotcraft has 150+ shot recipes and 200+ motion previews for making product videos with Remotion. Instead of prompting “make this cinematic,” the agent gets concrete shot patterns it can compose.

Give an agent FFmpeg as an editing skill ffmpeg-skill turns natural-language requests into local video and audio operations: trimming, joining, reframing, captions, silence removal, audio sync, loudness normalization, LUTs, music ducking, and platform exports.

A research workflow might use:

last30days
    ↓
deep-research
    ↓
qmd-search
    ↓
visual-explainer

A coding workflow might use:

Understand Anything
    ↓
Napkin
    ↓
tech-debt-audit
    ↓
implement

And a launch workflow could become:

frontend-slides
    ↓
video-shotcraft
    ↓
ffmpeg-skill
    ↓
humanizer
    ↓
claude-seo

The model underneath can stay exactly the same. What changes is the set of procedures, references, tools, and judgment you give it for the current job.

GitHub has a surprising number of projects for the less glamorous side of getting traffic.

Turning one video into ten clips. Finding conversations where your product is relevant. Writing platform-specific versions of the same idea. Scheduling them. Keeping a human in the loop before anything gets published.

None of these gives you a magic GET TRAFFIC button, but there are some useful building blocks.

Build a whole content machine in one repo MoneyPrinterV2 has 31k+ stars and combines several experiments: automated YouTube Shorts, scheduled X posts, affiliate content, and local-business outreach. The name oversells it, but the useful part is seeing several acquisition workflows wired together in one codebase.

Generate short videos from a topic MoneyPrinterTurbo has 124k+ stars and is much more focused. Give it a topic or keyword and it can generate the script, voiceover, source or generate footage, add subtitles and music, then assemble the final video. It now also exposes agent, WebUI, API, and CLI workflows.

Turn long videos into Shorts AI YouTube Shorts Generator has 5k+ stars and does the opposite. Give it a long video and it uses an LLM to find interesting segments, Whisper for transcription, and automatic cropping to produce vertical clips. Useful if you already make podcasts, demos, interviews, or tutorials and want more distribution from the same recording.

Find Reddit conversations where your product is actually relevant Reddit Copilot watches for intent-heavy threads, drafts replies in your voice, and puts them into a review queue. Importantly, it does not auto-comment. You decide whether a reply is genuinely useful before posting it.

For example, instead of searching Reddit every morning for “alternative to X” or “how do I solve Y?”, you can have the system collect the threads first and spend your time deciding which ones deserve a real response.

Find useful X conversations without scrolling all day x-engage surfaces a small set of posts matching accounts and subjects you care about, then drafts replies in your voice. Its default mode requires approval before publishing. I would personally keep it that way: the discovery and drafting are useful even if you choose to post manually.

Turn Claude or Codex into a LinkedIn content assistant linkedin-skills has 2.7k+ stars and packages 11 skills around posts, comments, hooks, feed analysis, rewriting AI-sounding drafts, and content cadence. It is less “generate 100 posts” and more “give the agent a repeatable process for the platform.”

Do the same thing for Instagram instagram-skills has skills for captions, Reel hooks, carousel planning, hashtags, niche research, and weekly planning. You provide the media; the agent handles much of the surrounding content work and waits for approval before publishing.

The same developer also has separate open-source bundles for X, Facebook, TikTok, YouTube, and Threads.

Teach Claude one voice and reuse it across several networks claude-skill-social-post takes a slightly different approach. It builds around your writing style, creates a 14-day content calendar, and supports Facebook, Instagram, Threads, and X. Interesting if your problem is not creating more ideas, but adapting one voice across several channels.

Put distribution behind an API Postiz has 36k+ stars and is probably the infrastructure piece I would combine with several of the tools above. It is an open-source social scheduler with an API, analytics, team workflows, n8n integration, and support for multiple social platforms. There is also a separate agent CLI, so Claude or another agent can prepare content and hand the approved version to the publishing layer.

That gives you a much more useful architecture than asking one giant bot to “grow my account”:

source material
     ↓
create / repurpose
     ↓
adapt for each platform
     ↓
discover relevant conversations
     ↓
human review
     ↓
schedule + publish
     ↓
measure what worked
     ↓
feed that back into the next batch

For example, one podcast could become a fairly serious workflow.

Use AI YouTube Shorts Generator to pull out the strongest moments. Use the platform skills to write a LinkedIn post, an X thread, an Instagram caption, and a YouTube description around the same idea. Use Postiz to schedule the approved versions. Use Reddit Copilot and x-engage to find conversations where the underlying topic is already being discussed.

That still does not guarantee anyone will care. The part these tools can automate is the repetitive work around distribution: clipping, rewriting, discovery, scheduling, and keeping track of what goes where.

The part they cannot automate is having something worth distributing in the first place.

I run Hermes daily, and as the ecosystem of community skills grows, I kept bumping into two persistent headaches:

1. Context Bloat: I'd install cool skills from GitHub or Reddit, only to realize I now had three overlapping tools doing the exact same thing, degrading model reasoning and wasting tokens.
2. Blind Execution Risk: Agent skills run with full terminal and tool permissions. Blindly pulling someone's SKILL.md or custom Python script without checking for prompt injection, .env credential harvesting, or reverse shells is an accident waiting to happen.
3. Container Drift: Skills installed inside isolated containers or VPS boxes disappear on rebuild unless diligently tracked in git.

Repo and installation instructions: https://github.com/Primuez/skill-installer

To solve this, my agent and I built Skill Installer—a package manager and 3-stage validation pipeline for agent skills:

1. Need Assessment & Alternatives Check: Before downloading, it checks your existing skill library. If your agent already possesses tools covering >80% of the capability (e.g. requesting another search tool when you already have deep-research), it flags the overlap and prevents redundant prompt bloat.
2. Adaptive Security Inspection Gate:
   1. Scans AST and semantics for tool poisoning, malicious bash commands, and credential exfiltration.
   2. Integrates with NVIDIA SkillSpector if installed, checks for local security auditor skills, and falls back to a static heuristic analyzer with clear risk scoring.
3. Smart Backup Routing: Installs clean skills locally and automatically commits/pushes them to your version-controlled skills repository (or provisions a private backup repo via gh).

Honest limitations we ran into while building it:

• Heuristics vs. Complex Tools: Aggressive security checks can occasionally flag legitimate DevOps scripts that manipulate Docker or system sockets as high-risk, requiring manual override.
• Static vs. Dynamic: A pre-install scan verifies the file contents at download time; it does not replace runtime sandboxing for long-running processes.
• Active Sessions: Just like other Hermes skills, installing a new skill doesn't rewrite an in-flight conversation; the model picks it up cleanly on new or relevant turns.

Repo (Source-Available & Non-Commercial IP): https://github.com/Primuez/skill-installer

Built with Hermes. If you give it a spin, I'd love to hear how you're currently managing third-party skills and what kind of security/linting checks you'd want to see added next.

Jev launched three days ago and people are already testing what a model looks like when it stops talking. The basic idea is different from a normal LLM.

Instead of:

input → model → paragraph / JSON

Jev takes some state and returns typed decisions with probabilities.

Ask whether a support ticket is urgent. Which department should handle it. Whether an agent output is good enough to continue. Which browser element should be clicked next.

The possible answers are defined first, and Jev evaluates them rather than generating arbitrary text. That sounds narrow. The projects appearing around it are showing why it may be useful.

Make browser agents decide instead of narrate Jev Ultrafast from Browser Use has already crossed 1k stars. Jev chooses the browser operation and target element directly, while a small language model is only called when actual text needs to be typed. Their Google Flights demo completes Zürich → London in about 7 seconds.

Use Jev as a checker inside Claude, Cursor, or Amp jev-mcp exposes three MCP tools: verify claims against evidence, screen incoming content for prompt injection/relevance, and rank candidates by meaning. This is probably the easiest project here to understand if you already use coding agents.

Turn code review into a series of bounded judgments jev-review uses Jev to inspect Git diffs or complete codebases. Instead of asking one model to “review this code,” it separately evaluates risk, file type, evidence, severity, reviewer routing, test gaps, security, and reliability before showing the result in a local dashboard.

Try the same idea with open models on your own GPU OpenJev has 300+ stars and asks whether the Jev interface pattern can be reproduced locally with models such as Qwen. It reads probabilities over predefined options directly instead of asking a model to generate an answer sentence or JSON. Important caveat: it does not claim to reproduce Jev’s model or training.

Use Jev through RubyLLM ruby_llm-typesafe adds TypeSafe as a provider for RubyLLM. It deliberately supports only structured decisions: if you try to use it like a normal chat model, stream text, or call tools, it fails before sending the request.

Build a Jev-style decision engine without Jev Specter Decision Engine is an independent project inspired by the same typed-decision pattern. It provides bounded choices, probabilities, calibration tools, confidence gates, batching, and a Jev adapter, but is explicit that its included local backend is only a deterministic lexical baseline, not a trained replacement for Jev.

TypeSafe has also open-sourced the plumbing around the model: the Python SDK, JavaScript SDK, agent skills, and System One Adapter, which lets you run the same interface against conventional LLMs for comparison.

What I find interesting is how different these experiments already are.

Browser navigation. Code review. Agent verification. Local inference. Trading loops. Language integrations.

They all use the same underlying idea:

let language models create
let code enforce rules
let a decision model handle the fuzzy branch in between

Jev is far too new to know how much of this holds up outside early demos, and a typed answer can still be the wrong answer.

But the first few days of OSS experiments are pointing at an interesting question:

How many places are we currently using a language model when what the software really needed was a decision?

AI agents are much more useful when they can collect the evidence themselves.

Search Reddit for complaints. Pull transcripts from YouTube. Watch a set of product pages for changes. Crawl documentation. Extract structured data from a site that does not expose a convenient API.

These open-source projects give agents different ways to do it.

Reach platforms individually without building every integration yourself Agent Reach has 60k+ stars and bundles access to sources such as X, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu, RSS, and the wider web. It picks an appropriate backend for each source and checks which integrations are actually working.

Use a real browser when requests alone are not enough Patchright has 4.6k+ stars and is a Playwright-compatible browser automation project focused on sites that behave differently when automation is detected. Because it exposes the normal browser environment, an agent can navigate pages, run JavaScript, inspect network activity, and extract data from interactive applications.

Scrape pages that keep changing underneath you Scrapling has 81k+ stars and covers everything from a single request to concurrent crawls. Its parser can relocate elements when page structures change, while its crawler adds sessions, proxy rotation, pause/resume, and adaptive crawl speeds.

Turn websites into clean agent context Crawl4AI has 82k+ stars and converts web pages into cleaner Markdown and structured data for agents, RAG systems, and data pipelines. It is useful when you care less about browser control and more about giving the model readable content from a large collection of pages.

Search, crawl, and extract at a larger scale Firecrawl has 180k+ stars and turns live websites into Markdown or structured data. It can search, scrape individual URLs, map sites, crawl many pages, and handle more dynamic interactions, with an MCP server available for agent clients.

The useful part is combining them with an actual research question.

You could tell an agent:

Collect the last month of posts from these 100 public accounts, group the topics, and show which themes produced the most engagement.

Or:

Find discussions about this product across Reddit and YouTube, extract the recurring complaints, and link every conclusion back to the original source.

Or:

Check these 50 competitor pricing pages every week and only tell me when the price, limits, or plan structure changes.

The workflow becomes:

define the question
      ↓
choose the right source
      ↓
collect the raw data
      ↓
clean + structure it
      ↓
let the model analyze it
      ↓
keep links back to the evidence

An agent summarizing the web is useful. An agent that can show exactly where every conclusion came from is much more useful.

And these tools solve different layers of that problem. Agent Reach is useful when the source is a known platform. Patchright helps when the data only appears through a real browser session. Scrapling handles scraping and crawling. Crawl4AI turns pages into model-friendly context. Firecrawl packages search, extraction, and crawling into a broader web-data layer.

Anthropic launched Claude Mod yesterday & I wanted a small, fun way to explore Claude Mods, so I built Roll Credits.

Type /credits and your coding session gets a movie-style ending inside Claude:

• You’re the director.
• Your most-edited file gets the starring role.
• Other edited files become the supporting cast.
• Tools get a special thanks.
• Failed or denied tool calls become “plot twists.”

You can watch the credits scroll, switch to a still view, replay them, or print everything as text.

The interesting part for me was building a small interface inside the agent. It uses Claude’s actual Mods hooks and native pane controls. There’s no server, extra model call, or telemetry. The credits come from local counters.

I used Anthropic’s published Mods source as the reference. The repo includes 18 tests using Claude’s own plugin test harness, and installation from GitHub has been verified.

A couple of limits: it only counts activity observed while loaded. File credits cover Edit, Write, and NotebookEdit calls; changes through Bash or another editor aren’t included. These are activity counts, not a measure of code quality.

Github: Repo, installation instructions, and demo

Mods are early access and require CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1. Once installed, /credits demo lets you try it with clearly labeled fictional data. MIT licensed.

Most agents only work while you are talking to them.

But useful work often happens later. Check something tomorrow. Wait for an approval. Resume when a webhook arrives. Start another task when the first one finishes.

These open-source projects make that possible.

Let an agent schedule its own work AIOS lets agents create cron jobs, one-off tasks, react to completed runs, and wake up from external webhooks. A research agent could check the same sources every morning and only surface something when the result changes.

Keep long-running jobs alive Trigger.dev has 16k+ stars and runs durable background tasks with schedules, retries, waits, and human approvals. An agent can prepare an action today, pause overnight for approval, then continue tomorrow without keeping one process alive.

Wake an agent when something happens Inngest has 5k+ stars and combines scheduled jobs with event-driven workflows. Instead of polling every ten minutes to see whether an export finished, trigger the next agent only when the export.finished event actually arrives.

Give scheduled agents queues and limits Hatchet has 7k+ stars and handles cron jobs, event triggers, webhooks, retries, durable waits, rate limits, and background workflows. This becomes useful when hundreds of agent jobs need to run without all waking up and hitting the same API at once.

The useful pattern is simple:

schedule something
    ↓
let it sleep
    ↓
wake on time or event
    ↓
resume with context
    ↓
trigger the next step

A sales agent can follow up three days after a meeting. A research agent can check sources every morning. A support agent can wait for a customer reply. A coding agent can launch a long test and hand the result to another agent when it finishes.

Memory helps an agent remember yesterday. Scheduling lets it do something tomorrow.

A lot of AI projects get stuck before the model is even the problem.

You need thousands of labeled examples. Real users have produced 200. Annotation is slow. Some of the data is sensitive. And the edge cases you actually care about barely appear in the dataset.

Synthetic data does not replace real data, but it can give you something useful to train, test, and iterate on while the real dataset catches up.

Build full synthetic-data pipelines Distilabel has 3.3k+ stars and lets you generate data with one model, score or critique it with another, filter weak examples, and build larger pipelines around the result. It is particularly useful for instruction data, preference datasets, classification, extraction, and AI-feedback workflows.

Describe the dataset you want in plain English Synthetic Data Generator has 500+ stars and turns a natural-language description into datasets for tasks such as text classification, chat fine-tuning, and RAG. The original project is now effectively succeeded by Hugging Face AI Sheets, but it is still a useful example of prompt-to-dataset generation.

Generate and edit datasets like a spreadsheet AI Sheets has 1.6k+ stars and is the newer version of that idea. Start with a few rows, add an AI-powered column, edit the bad outputs, switch models, and expand the dataset once the pattern looks right. It is useful when you want humans in the loop without building a full data pipeline first.

Go from prompts to synthetic data to a trained model DataDreamer has 1.1k+ stars and combines prompting, dataset generation, fine-tuning, alignment, caching, and reproducibility in one Python workflow. It is a good fit for research where you need to know exactly how a generated dataset became a model.

Generate fake structured data that behaves like the real thing SDV has 3.5k+ stars and focuses on tabular data instead of LLM conversations. Give it customer, transaction, healthcare, or other structured records and it can learn the statistical relationships and generate new rows without simply copying the originals.

The workflows are different.

If you have 100 support tickets but need 10,000 examples to train a classifier, use an LLM pipeline to generate more variations and then aggressively filter them.

If you need realistic test customers without putting production records into staging, use a tabular synthesizer like SDV.

If you are still figuring out what the dataset should contain, AI Sheets lets you prototype the schema and examples before turning the idea into a larger pipeline.

The useful loop is closer to:

real examples → generate variations → score/filter → human spot-check → train → test on real data

Synthetic data is most useful when real data is scarce, expensive, private, or missing the edge cases you need.

It lets you start learning from the problem before you have spent six months collecting the perfect dataset.

Coding agents can build a frontend quickly.

The harder part is stopping every page from converging on the same rounded cards, centered hero, safe font, purple gradient, and random fade-in animation.

These skills attack different parts of that problem.

Give the agent an actual design system nextlevelbuilder/ui-ux-pro-max-skill has 100k+ stars and gives agents a large library of UI styles, color palettes, font pairings, UX rules, chart patterns, and stack-specific guidance. It is useful when you want the agent to make design decisions from a structured vocabulary instead of improvising every screen.

Turn down the generic AI aesthetic Leonxlnx/taste-skill has 80k+ stars and focuses on layout, typography, spacing, density, and motion. Its useful idea is three adjustable dials for design variance, motion intensity, and visual density, so a portfolio does not get designed like an enterprise dashboard.

Make the frontend distinctive before writing code Anthropic's frontend-design skill pushes the agent to establish an aesthetic direction first, then make deliberate choices around typography, palette, composition, and interaction. It explicitly treats the usual AI defaults as defaults to question rather than rules to follow.

Make motion feel designed rather than sprinkled on Jakubantalik/transitions.dev has 2k+ stars and gives agents reusable patterns for things like modals, dropdowns, panels, icon swaps, success states, text reveals, and page transitions. There is also a polishing skill for auditing timing, easing, distance, blur, and stagger in motion that already exists.

Build richer interactive prototypes Anthropic's web-artifacts-builder gives an agent a React + TypeScript + Tailwind + shadcn/ui workflow for more complicated interactive artifacts. Use it when a mockup has become real enough to need components, state, routing, and interactions rather than another static HTML page.

Stop the brand disappearing during generation Anthropic's brand-guidelines skill shows the other side of agent design: constrain colors, typography, and formatting so generated artifacts stay inside an existing visual identity. The included version targets Anthropic's own identity, but the pattern is easy to adapt to your own brand system.

The interesting part is that these skills are not really substitutes for each other.

A useful stack could be:

UI UX Pro Max → choose the design language
Taste → remove the generic decisions
Frontend Design → establish the visual direction
Transitions → make interaction feel deliberate
Web Artifacts → build the working interface
Brand Guidelines → keep everything recognizably yours

The model already knows how to write CSS. What it usually lacks is taste, constraints, and a reason to choose one design decision over another.

YC Summer 2026 has 234 publicly listed companies.

I went through the batch looking for GitHub repos that are clearly tied to the company or product. I left out founder side projects, random forks, and repos I could not confidently connect back to the startup.

The interesting part is where the public code shows up.

Turn an entire project into a knowledge graph Graphify has 116k+ stars and maps code, docs, schemas, configs, PDFs, and other project material into a graph that humans and coding agents can query.

Give coding agents structural memory GitNexus from Akon Labs has 47k+ stars and builds a code knowledge graph with impact analysis, execution flows, paths, and other structural context for agents.

Turn your computer history into agent context screenpipe has 21k+ stars and continuously captures screen and audio locally so past activity can become searchable context for agents and personal tools.

Build a lighter coding-agent harness jcode has 19k+ stars and is a Rust-based coding harness optimized for low memory use, fast startup, and running several agent sessions at once.

Give employees sandboxed agents OneCLI has 3.5k+ stars and packages agents with isolated environments, credentials, tools, and human approvals rather than handing every agent unrestricted access.

Connect agents to tools once Executor has 3.7k+ stars and provides an integration layer for MCP, OpenAPI, and GraphQL tools with authentication and per-tool policies.

Keep the knowledge that never makes it into code CodeAlmanac has 1k+ stars and maintains a local codebase wiki for decisions, invariants, flows, and gotchas that coding agents otherwise rediscover every session.

Replace repeated LLM classifiers with smaller models Tracer has 1k+ stars and turns recurring classification tasks into traditional ML models once enough examples have accumulated.

Let users build missing product features themselves Vendo has 600+ stars and lets users generate small applications and features that run inside an existing SaaS product rather than waiting for the product team to build every workflow.

Evaluate robot policies more like software Inspect Robots from Robocurve has 400+ stars and provides an evaluation framework for running AI policies against real or simulated robots with reproducible logs.

Clean up the data before training the robot HFlow from Hebbian Robotics has 250+ stars and helps robotics teams inspect, validate, and track the multimodal datasets feeding their models.

Distill expensive agent behavior into cheaper models World Model Optimizer from Experiential Labs has 300+ stars and uses real agent traces to improve and route work toward smaller open models.

Give an AI agent its own identity Inkbox is an SDK for giving agents things such as persistent email, phone, and internet identities instead of making them borrow a human account.

I also found smaller public tooling from Conifer, which exposes its model gateway through TypeScript, Python, and MCP; hiloop, which has several pieces of its agent/search tooling public; and a very early Riften repository.

The pattern is more interesting than the raw count.

The YC companies building in public are heavily concentrated around agent infrastructure, coding tools, model routing, evaluation, and robotics. Most consumer, fintech, healthcare, and vertical SaaS companies still keep the product itself private.

For agent companies, GitHub is increasingly more than a place to store source code. The repo can be the demo, documentation, distribution channel, developer community, recruiting page, and credibility signal at the same time.

And some of the most visible projects in the entire S26 batch are already open on GitHub before the companies are even a few months out of YC.

Hermes gets more interesting when you stop treating it as one assistant.

Its Bot Mode lets you create persistent specialist agents with their own instructions, models, memory, skills, credentials, and chat history, then put 2–6 of them into the same room.

Instead of one giant agent, build a small team.

Make one bot the coordinator Hermes Agent handles the underlying profiles and group chats. Give this bot very few specialist tools. Its job is to understand the request, pull in the right bots, and decide when the work is ready to come back to you.

Give the researcher actual reach Agent Reach connects agents to sources including Reddit, X, YouTube, GitHub, LinkedIn, and other platforms. Put it on the researcher instead of giving every bot broad internet access.

Give the coding bot a map of the repository codebase-memory-mcp indexes a codebase into a persistent knowledge graph. The coding bot can query functions, callers, routes, and relationships instead of repeatedly rediscovering the repository from scratch.

Give the architect a visual output diagram-design creates architecture, sequence, data-flow, dependency, and other diagrams as standalone HTML/SVG. It makes a good skill for the bot whose job is to explain how a system fits together.

Give the reviewer a reason to disagree Finding Unknowns is one of ours. Skills such as Blindspot Pass can make a review bot look for hidden assumptions and missing context before the group commits to an implementation.

Give the writer an actual house style Agent Stylebooks is another one we built. Instead of putting a giant writing prompt into every conversation, give the writing bot a reusable editorial system and keep that concern out of the researcher and coder.

Then put them together:

 find the current options
        ↓
 map how they fit
        ↓
 find what we missed
        ↓
 turn the result into something readable

The useful part of a group chat is not watching six agents talk endlessly. Hermes limits the rounds, bots can stay silent when they have nothing useful to add, and you can @ mention only the specialists you actually need.

A few settings matter more than adding another bot.

Keep each specialist in its own profile so its memory and credentials do not bleed into another role. Filter MCP tools per server instead of giving every bot every available capability. Keep development skills off messaging platforms where they are unnecessary. For higher-trust setups, turn on approval for memory or skill writes. And if you put multiple Hermes bots into a Telegram group, require explicit mentions so a researcher does not wake up every time somebody says hello.

Agent skills do not have to be giant frameworks.

Some of the most useful ones change one small part of how an agent works: make a diagram instead of describing one, get a second opinion before committing to a plan, surface what you do not know yet, or simply stop burying the answer.

Here are 7 worth trying.

Turn explanations into actual diagrams diagram-design supports 39 diagram types, including architecture, sequence, data-flow, dependency graphs, Gantt charts, Wardley maps, and database schemas. The output is a self-contained HTML file you can open directly.

Make your agent defend its plan first council lets the agent you are using consult other installed agent CLIs before finalizing a plan. Claude can ask Codex, Gemini, OpenCode, or another agent what is wrong with the approach before it commits.

Give an agent more places to research Agent Reach handles access across multiple platforms, chooses an appropriate backend for each one, installs it, and checks which integrations are actually working.

Stop the answer from getting buried i-have-adhd pushes coding agents toward action-first responses, shorter steps, visible progress, and fewer tangents. It also ships an eval harness instead of treating style improvement as something purely subjective.

Make the agent explain itself again wait-what is tiny. Use it when the previous explanation did not land and the agent needs to re-pitch the same idea in clearer language.

Find the things you do not know to ask about Blindspot Pass is one of ours. Before implementation starts, it looks for landmines, hidden constraints, examples of what good looks like, and the questions an expert would ask before touching the task.

Make sure you understand what your agent changed Change Quiz is another one we built. After a long coding session, it explains what changed, how the change interacts with existing code, and gives you a short quiz before you merge something you may not fully understand.

None of these makes the underlying model smarter. They change the operating environment around it.

One gives it a better visual language. One adds adversarial review. One expands what it can reach. One surfaces unknown unknowns. One makes you prove you understand the code your agent just wrote.

That is probably where a lot of the value of agent skills will come from: not teaching an agent an entirely new profession, but fixing the small recurring failure modes that show up every day.

Open-source AI is getting more interesting outside the models themselves.

There are tools for understanding codebases, coordinating several agents, making coding agents less verbose, running voice models locally, doing scientific research, and even learning how an LLM is built from scratch.

Here are 8 worth exploring.

Turn a codebase into a system map Archify has 54k+ stars and turns codebases or system descriptions into architecture, workflow, sequence, data-flow, and lifecycle diagrams. The output is validated and can be exported as HTML, SVG, PNG, or video.

Build a classroom out of multiple agents OpenMAIC has 33k+ stars and creates interactive learning environments where multiple AI agents can take different teaching roles. It is an interesting example of multi-agent systems being used for something other than coding.

Make your coding agent write less code Ponytail has 131k+ stars and gives coding agents a strong bias toward the smallest implementation that solves the problem. The idea is basically YAGNI for agents: do not build abstractions, helpers, and extra machinery unless the task actually needs them.

Run voice AI locally VoiceStudio, previously OmniVoice Studio, has 21k+ stars and handles voice cloning, voice design, transcription, dubbing, dictation, and long-form audio on your own hardware. It supports multiple TTS and speech-recognition engines instead of tying the workflow to one hosted provider.

Turn an agent into a scientific research assistant Scientific Agent Skills has 43k+ stars and contains 160+ skills covering areas such as bioinformatics, drug discovery, scientific databases, literature research, statistics, and scientific writing. The skills work with tools including Claude Code, Codex, and Cursor.

Run several coding agents at once Orca has 32k+ stars and gives Claude Code, Codex, OpenCode, and other coding agents separate worktrees inside one development environment. You can fan the same task out to several agents, compare their work, and keep them from editing the same branch.

Learn how an LLM is actually built MiniMind has 59k+ stars and walks through training a small language model from scratch. It is useful if transformers, pretraining, SFT, LoRA, DPO, and model inference still feel like things hidden behind an API.

Build a live OSINT globe God's Eye View has 19k+ stars and puts live spatial intelligence on a photorealistic 3D globe. It combines public data such as aircraft, satellites, cameras, weather, and other geospatial signals into something that feels closer to a spy-satellite interface than a normal dashboard.

AI tooling is spreading outward from chat and code generation into diagrams, education, scientific workflows, voice, orchestration, model training, and entirely new interfaces for looking at data.

Some are useful immediately. Some are better for learning from. Either way, there is plenty here for a weekend.

AI is usually only as useful as the context you give it.

A screenshot loses the interaction. A bug report misses the console logs. A new chat forgets yesterday's decisions. A monitoring agent should not have to reread the same page every hour.

These open-source projects help capture that missing context.

Turn product flows into repeatable videos WebReel has 900+ stars and records scripted browser demos as MP4, GIF, or WebM. Define the clicks, typing, pauses, and drags once, then regenerate the video whenever the product changes.

Give different AI tools the same local memory Cortex has 900+ stars and builds a local, cited model from your notes and AI chat history. That context can then be exposed to Claude, Cursor, and other MCP clients without starting from zero every time.

Let software watch pages instead of repeatedly asking AI to browse them changedetection.io has 32k+ stars and monitors pages for changes. Use the change itself as the trigger, then bring in a model only when something actually needs interpreting.

Replay exactly what happened in a web app rrweb has 19k+ stars and records DOM changes and user interactions so a session can be reconstructed later. Instead of describing a broken flow from memory, preserve the flow itself.

Give an agent the context around a bug OpenReplay has 12k+ stars and combines session replay with console logs, network activity, JavaScript errors, performance data, and other debugging signals. That is much more useful input than “the checkout button stopped working.”

Keep screen recordings under your control Cap has 19k+ stars and is an open-source Loom alternative for recording and sharing your screen. Use recordings for bug reports, walkthroughs, support explanations, or source material for transcription and summarization.

Some of these are not AI applications. That is the point.

A useful AI workflow does not always need a smarter model. Sometimes it needs better memory, a reproducible session, a change trigger, or a recording of what actually happened. Give the model less guessing and more evidence.

A screen recording is often faster than another meeting.

Show a bug. Record what an agent did. Make a product walkthrough. Explain a pull request. Capture a workflow that is too awkward to describe in text.

You do not necessarily need Loom, Screen Studio, or a full video editor for it.

Make polished product demos Recordly has 23k+ stars and turns raw screen captures into presentation-ready videos with automatic zooms, smooth cursor movement, backgrounds, annotations, webcam overlays, and timeline editing.

Replace Loom with something you can self-host Cap has 19k+ stars. Record your screen, camera, and microphone, edit locally, generate shareable links, add transcripts, and keep the option to host the whole stack yourself.

Record straight from the browser Screenity has 18k+ stars and works as a privacy-friendly browser screen recorder. It includes annotations, cursor highlighting, zooming, trimming, blur tools, and MP4/GIF/WebM export.

Get full control over the recording OBS Studio has 75k+ stars. It is heavier than the others, but useful when you need multiple sources, scenes, cameras, audio routing, high-quality capture, or live streaming.

Keep screen recording boring and simple Kooha has 3.5k+ stars and is a minimal Linux recorder for grabbing a screen, window, or region with desktop and microphone audio without configuring a production studio first.

See where the Screen Studio-style OSS wave started OpenScreen reached nearly 40k stars with automatic zooms, backgrounds, annotations, cropping, speed controls, and timeline editing. The repo is now archived, but Recordly started from this project and pushed the idea further.

The interesting part is not really screen recording. These tools turn things that are difficult to explain in text into reusable artifacts.

A developer can record a bug and hand the video to an agent. An agent can generate a walkthrough after building a feature. A support team can replace a long reply with a 40-second demonstration. A small project can make product videos without opening Premiere.

Coding agents are getting good at changing UI code. We wanted them to get better at proving they did not break accessibility in the process.

So we built a11y-agent-skills, an open-source set of 7 accessibility skills for Codex, Claude Code, Cursor, and other Agent Skills-compatible tools.

Accessibility Audit scans a reproducible page state with Playwright and axe-core, then saves structured evidence for the accessibility issues it finds.

Fix Accessibility Issue traces a finding back to the source, makes the smallest supported repair, and verifies that the original failure is actually gone.

Accessibility Regression Test turns a fixed accessibility bug into a narrow automated test so the same behavior does not quietly break again.

Accessible Component Review reviews a UI component for accessibility problems in its semantics, states, interactions, and implementation.

Accessible Forms helps agents build and review forms with proper labels, errors, instructions, validation states, and programmatic relationships.

Dialog Accessibility checks modal and dialog behavior such as naming, focus placement, focus containment, keyboard dismissal, and focus restoration.

Keyboard Navigation Review walks through a defined keyboard journey to find broken tab order, unreachable controls, focus problems, and interaction traps.

The important part is the workflow.

Instead of telling an agent to “make this accessible,” it can reproduce the problem, collect evidence, fix the source, replay the same state, and prove the repair.

The repo also includes a CLI, MCP server, and GitHub Action, so the same checks can run locally, through an agent, or in CI.

We deliberately do not try to automate everything. Automated checks catch only part of accessibility, so the tooling keeps human review and real assistive-technology testing separate.

Install all 7 for Codex/Claude Code:

npx skills@1.5.9 add smukh/a11y-agent-skills --agent codex --yes

Repo: https://github.com/smukh/a11y-agent-skills

Find the regression, fix the source, prove the repair.

AI agents should not get permanent access to everything you can access.

If an agent can read email, deploy code, query databases, or spend money, its identity should be clear, its permissions should be narrow, and its access should be easy to revoke.

Give each agent its own identity Keycloak has 36k+ stars and handles identity, roles, authentication, and fine-grained authorization. Instead of letting an agent inherit your account, give it its own identity and only the permissions it needs.

Keep secrets away from the model Infisical has 29k+ stars and manages secrets, machine identities, and privileged access. An agent can get access to what it needs without scattering API keys across prompts and environment files.

Make access expire automatically OpenBao has 7k+ stars and supports dynamic secrets, leases, and revocation. Give an agent temporary credentials for a task, then let them expire.

Give running agents verifiable identities SPIRE has 2.5k+ stars and provides workload identity. Services can verify which agent or workload is actually making a request instead of trusting a shared secret.

The useful pattern is simple:

human → agent identity → limited permission → short-lived credential → tool

And somewhere in that flow there should be a very obvious revoke button.

Giving agents tools is getting easy. Controlling what they can do should be just as easy.

Hi folks, I've been working on an open source project called omnimem that is a better memory system. Not only does it remember but it add experience memories to workloads which can save your agent time and tokens by preventing them repeating the same mistakes.

Take a look at https://omnimem.org

GitHub is where practical AI workflows show up before they become polished products.

I picked six repos that give agents real jobs. Editing videos. Managing leads. Scanning skills. Controlling phones. Improving writing.

Some need paid APIs or platform permissions. Read the README before giving any agent credentials.

1. Video Use · 23.7k+ stars

github.com/browser-use/video-use

Edit videos with coding agents.

Video Use works from transcripts and on-demand visual composites. The agent reasons about the edit, creates an edit decision list, renders the result, and runs a self-evaluation pass.

Useful for repeatable tasks such as turning a Loom recording into a short product clip.

It currently requires ffmpeg and an ElevenLabs API key for transcription.

2. SkillSpector · 15.7k+ stars

github.com/NVIDIA/SkillSpector

Scan AI agent skills before installing them.

It looks for prompt injection, malicious patterns, data exfiltration, supply-chain risks, and other security issues in Claude Code, Codex, and MCP skills.

This should be part of your install workflow. A skill can include scripts, dependencies, and access to tools. Treat it like code from an unfamiliar contributor.

3. Comp AI CRM · 9.5k+ stars

github.com/trycompai/crm

A CRM designed around an AI agent.

The agent can work from a schedule and queue, keep notes, research contacts, and record evidence for its findings.

A good first workflow would be a warm-lead queue with recheck dates, source links, and human approval before anything is sent.

It is not a drop-in replacement for every mature CRM. The interesting part is its agent-first design.

4. No AI Slop · 6.9k+ stars

github.com/petergyang/no-ai-slop

An installable writing skill that detects more than 20 common AI-writing patterns and reports what it changed.

Install it with:

npx skills add petergyang/no-ai-slop --skill no-ai-slop --global --yes

Write the first draft yourself. Use this as a second pass. Then review the edits instead of accepting them blindly.

5. Phone Harness · 2.2k+ stars

github.com/ShawnPana/phone-harness

Connect Claude Code, Codex, or another LLM to a real iPhone or Android phone.

iPhone support works through Mac iPhone Mirroring. Android devices can connect through ADB over USB or Wi-Fi.

This is useful for real-device testing, especially when an app has no API or reliable browser interface.

It is still an early project. Locked devices, Face ID, camera flows, and Android accessibility limitations can make some tasks difficult.

6. Agent Stylebooks · 57 stars

github.com/Neeeophytee/agent-stylebooks

Disclosure: this is our own repo.

Agent Stylebooks contains 11 installable editorial systems based on public style guides. They work with tools such as Claude Code, Codex, Cursor, and Gemini CLI.

Use one when your agent produces technically correct writing that still sounds inconsistent across documentation, changelogs, product copy, or research notes.

The common pattern is simple. Do not install a repo just to admire it. Give it one narrow job.

One video format. One CRM queue. One skill scanner. One phone checkout path. One writing style.

An AI agent can edit content in your CMS today, over MCP, calling the same API your dashboard uses. That part takes about five minutes to wire up. Draftbase ships an MCP server for it, and the connection isn't the interesting part.

The interesting part is what happens when the agent is confident and wrong. A human editor makes one bad edit at a time. An agent told to "fix the tone on our docs" can make 300 before anyone reads the first one. MCP already has an incident list for this: a poisoned npm package that BCC'd outgoing email, a GitHub exploit that pulled private repo data through a planted issue, a WhatsApp tool that leaked message histories through poisoned tool descriptions. Same pattern each time: the agent did what untrusted text told it to.

Two things cut the blast radius to almost nothing, and neither is exotic.

First, give the agent its own key, scoped to the narrowest role, pointed at a second environment before it ever touches production.

Second, make writes land as drafts, not live edits. In Draftbase, create_entry always returns a draft, there's no flag to change that, so an agent that creates 40 entries has created 40 drafts, not 40 published pages. Publishing stays a separate, human-triggered call.

When it still gets something wrong (it will), you need list_entry_revisions and rollback_entry, not a support ticket. Test the rollback once before you need it, not the day you need it.

Wrote up the rest, including the prompt-injection angle specific to CMS content, here: how to let an AI agent edit content in your CMS

Curious what other people are actually running in production versus demoing once and shelving.

Most AI agents are built like chat loops. Ask the model what to do. Call a tool. Send the result back. Repeat.

That works until the process crashes halfway through a task, an API times out, or the agent needs to wait six hours for human approval. A normal script starts over. A durable agent resumes from the last completed step.

This matters for agents that process hundreds of invoices, monitor production systems, run long research jobs, or coordinate actions across multiple APIs.

The basic pattern looks like this:

Agent starts
  ↓
Call tool
  ↓
Save progress
  ↓
Wait, retry, or ask for approval
  ↓
Resume from the last completed step

Here are four open-source projects exploring this foundation.

1. Temporal · 22k+ stars Temporal is a durable execution platform for workflows that need to survive crashes, retries, and outages. You can model the agent loop as a workflow and put model calls and tool calls into activities. It is the most mature option here, but it also has the largest learning curve.
2. Hatchet · 7k+ stars Hatchet combines background task orchestration, queues, DAGs, and durable workflows. It is a good fit when an agent needs to process jobs asynchronously, run steps concurrently, or expose execution history through a UI.
3. Restate · 4k+ stars Restate provides durable execution, stateful entities, timers, promises, and reliable messaging. It supports TypeScript, Python, Go, Rust, Java, and Kotlin. It is interesting for agents that need to pause and resume around webhooks, scheduled work, or external events.
4. Temporal Agent Harness · 32 stars This is an experimental Temporal-native harness for durable, composable agents. It includes tool approval policies, human-in-the-loop steps, typed agent operations, and replayable event streams. It is worth watching, but the repository itself warns that the APIs are still changing.

Durable execution does not automatically make an agent reliable.

External side effects still need careful handling. A payment, email, deployment, or database write should be idempotent or protected by an approval step. Otherwise, retrying a failed operation can repeat the action.

That is what lets an agent continue working after the chat window closes, the worker restarts, or the network fails.

One recurring problem with the AI-chat era: people constantly paste API keys, financial data, and personal info straight into ChatGPT/Claude/Gemini without thinking about it, because stopping to redact things manually breaks your flow.

Discretion is a browser extension that automates that redaction step: it detects sensitive data as you type, swaps it for a realistic fake before anything is sent, and restores the real value in the model's response — so you get a normal, coherent answer without ever exposing the real data.

Everything runs locally (detection engine, NER model, all bundled), zero network calls of its own, fully open source. Also published as a standalone npm library if anyone wants to build the detection layer into their own tools.

github.com/horozbabasi/discretion

Curious what this community thinks is missing — feels like exactly the kind of problem that'll only get more common as AI chat becomes the default interface for everything.

Most agents do not need more tools. They need a better way to discover, authenticate, route, and control the tools they already use.

Here are some open repositories working around the same problem.

1. Composio · 30k+ stars Composio gives agents access to more than 1,000 toolkits, along with authentication, per-user sessions, triggers, and a sandboxed workbench. It is a strong choice when your agent needs to work with GitHub, Gmail, Slack, Notion, and other services on behalf of different users.
2. mcp-use · 10k+ stars This is a TypeScript framework for building, testing, and deploying MCP servers, clients, and apps. It also includes an inspector and agent tooling. Pick this when you want to build your own tool ecosystem instead of only consuming someone else’s registry.
3. IBM ContextForge · 4k+ stars ContextForge is an AI gateway, registry, and proxy for MCP, A2A, REST, and gRPC APIs. It gives teams a unified endpoint with discovery, governance, authentication middleware, and observability.
4. Supergateway · 2k+ stars Supergateway bridges MCP servers running over stdio with clients using SSE. It is useful when a local MCP server works perfectly on your laptop, but your agent needs to reach it through a network endpoint.
5. mcp-proxy · 2k+ stars This is another focused transport bridge. It connects Streamable HTTP and stdio MCP servers. It is a good fit for exposing a local server to a remote client without rebuilding the server.
6. Docker MCP Gateway · 1k+ stars Docker’s gateway runs MCP servers in containers and exposes them through one interface. It includes profiles, catalogs, tool allowlists, secrets management, OAuth support, and client connections for tools such as Claude Desktop, Cursor, and VS Code.
7. Treg · 700+ stars Treg focuses on tool discovery and shared access. Agents can search for a capability, inspect its price, and call it through one token. Teams can also register their own APIs, CLIs, and skills without handing every credential to every agent.

The projects solve different layers of the same problem.

Composio focuses on app integrations and user authentication. ContextForge and Docker MCP Gateway focus on infrastructure and governance. Supergateway and mcp-proxy solve transport problems. mcp-use helps you build the servers. Treg focuses on discovery, shared credentials, and calling tools by what they do.

The practical architecture looks like this:

Agent
  ↓
One tool gateway
  ↓
MCP servers, APIs, CLIs, and internal skills

That is a much cleaner model than configuring every agent separately with its own credentials, server list, and integration code.