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.

Claude Code out of the box is good.

Claude Code with the right OSS layer starts looking like a startup team, memory system, security analyst, researcher, QA engineer and personal assistant sitting behind one terminal.

Here are 10 repos worth knowing.

01 Make Claude stop shipping broken code

affaan-m/ECC — 210k+★

ECC adds planning, testing, repo analysis, security checks and persistent project context. The goal is simple: fewer fake “fixed” messages, fewer broken commits, less re-explaining your codebase every session.

02 Turn one Claude into an engineering org

garrytan/gstack — 115k+★

GStack gives you workflows that behave like a CEO, engineering manager, reviewer, QA lead and release engineer.

Idea → architecture → review → browser QA → ship.

03 Give the agent actual engineering discipline

mattpocock/skills — 145k+★

Matt Pocock’s skills force Claude to ask better questions, use TDD, debug systematically and keep architecture from rotting.

Basically: less vibe coding, more software engineering.

04 Stop rereading the whole repo every session

safishamsi/graphify — 70k+★

Graphify turns your code, docs, PDFs and folders into a queryable knowledge graph.

Instead of burning huge context windows rereading everything, the agent asks the graph what it needs.

05 Give Claude memory beyond the codebase

garrytan/gbrain — 24k+★

GBrain builds a searchable graph across people, companies, meetings, notes and decisions.

Think: “what do I need to know before tomorrow’s meeting?” and get an answer from everything you’ve accumulated.

06 Scan skills before giving them your machine

NVIDIA/SkillSpector — 5.5k+★

Agent skills can access files, networks and environment variables.

SkillSpector scans them for prompt injection, hidden instructions, suspicious code and excessive permissions before you install them.

07 Turn Claude into a security analyst

mukul975/Anthropic-Cybersecurity-Skills — 4k+★

817 structured cybersecurity skills covering malware analysis, incident response, threat hunting, cloud security and frameworks like MITRE ATT&CK and NIST.

Instead of asking Claude to “check security,” give it an actual procedure.

08 Turn the agent into a video studio

calesthio/OpenMontage — 18k+★

OpenMontage can research a topic, write the script, find or generate visuals, add narration and music, edit the timeline and render the final video.

One prompt → finished MP4.

09 Give it jobs too big for one agent

bytedance/deer-flow — 74k+★

DeerFlow breaks large tasks into sub-jobs, spins up specialist agents, runs code in sandboxes and produces finished artifacts like reports, dashboards and slide decks.

This is where “chatbot” starts turning into “delegation.” 10 Break the agent out of the terminal

openclaw/openclaw — 250k+★

OpenClaw puts the agent into WhatsApp, Telegram, Slack, Discord and other apps so it can handle email, calendars, research and tools while running locally in the background.

Not a coding copilot anymore.

More like an agent that lives on your machine.

AI can already turn a question into 30 sources and a polished report.

That is not really the hard part anymore.

The useful research stack is the one that can keep track of where evidence came from, which sources support which claims, and where the sources disagree.

These 8 open-source projects cover different parts of that pipeline.

Research the question end-to-end: GPT Researcher splits a question into research tasks, searches in parallel, tracks sources, filters what it finds, and turns the evidence into a cited report. It can work across both the web and local documents.

Look at the problem from several directions: STORM from Stanford does something I particularly like: before writing, it generates questions from different perspectives and simulates conversations between a writer and topic experts. That helps avoid a research report built around the first framing the model happened to choose.

Search without handing the whole workflow to a closed research product: Vane, formerly Perplexica, is an open-source answer engine with web, discussion, academic-paper and domain-specific search. It can also run against local models through Ollama.

Turn messy websites into evidence your agent can actually use: Crawl4AI converts webpages into clean, LLM-ready Markdown. This is the plumbing layer: search finds the page; Crawl4AI gets the useful content out of it.

Research inside the scientific literature: PaperQA2 is built specifically around high-accuracy RAG over papers and other documents. It retrieves literature, checks metadata including retractions, answers questions with citations, and can work on contradiction detection.

Actually read the PDF instead of flattening it into bad text: Docling understands PDF layout, tables, formulas, reading order, images and many other document formats, then turns them into structured representations that research agents can work with.

Connect evidence scattered across many sources: GraphRAG extracts entities and relationships from unstructured documents and organizes them into a graph. That makes questions such as “how do these people, companies, claims and events connect across 100 documents?” much easier than ordinary chunk retrieval. Microsoft now considers the original repo largely maintenance-mode, but the architecture is still useful.

Retrieve through both text and relationships: LightRAG combines retrieval with a knowledge graph and now supports reranking, multimodal documents, multiple chunking strategies and different models for different stages of the pipeline.

Put them together and the research loop starts looking less like:

question
   ↓
search
   ↓
LLM writes report

and more like:

question
   ↓
split into research questions
   ↓
search from multiple perspectives
   ↓
crawl + parse the evidence
   ↓
read papers / tables / PDFs
   ↓
connect entities + claims
   ↓
retrieve supporting evidence
   ↓
compare conflicts
   ↓
cite
   ↓
report

That last half is the part I think people underestimate.

Finding 60 sources is easy.

The harder question is whether source 17 actually supports the sentence the agent wrote, whether sources 23 and 41 contradict it, whether the paper was retracted, and whether a confident-looking conclusion survives after those conflicts are exposed.

Andrej Karpathy made an interesting point today: one way to make LLM outputs easier to understand is to ask them to write in ASD-STE100, the controlled English originally designed for aerospace maintenance manuals.

Not to make AI “sound human" but to make it easier to understand.

We spend a lot of time telling agents:

>be concise
sound professional
avoid AI slop

But different jobs need different writing systems.

A setup guide should be procedural. A research report should preserve evidence and uncertainty. An error message should tell you what happened and what to do next. A technical explanation should optimize for comprehension, not personality.

This is exactly why we built Agent Stylebooks.

Neeeophytee/agent-stylebooks packages 16 editorial systems as installable Agent Skills for Claude Code, Codex, Cursor, Hermes, Copilot, Gemini CLI and others.

Instead of:

>“write this better”

you can say:

setup guide       → Google Developer Docs
product help      → Microsoft
public guidance   → GOV.UK
research report   → NASA
risk disclosure   → SEC Plain English
interface copy    → Apple

The skill changes what comes first, how information is ordered, what ambiguity is unacceptable, and how the result should be checked.

A few other OSS projects fit around the same idea:

ASD-STE100 Writer Skill turns Simplified Technical English into an installable agent skill. Short sentences, controlled vocabulary, active constructions and fewer ambiguous instructions. Karpathy’s post is a good example of why this style is suddenly relevant outside aviation.

Vale has 6.2k+ stars and takes the next step: make writing rules testable. You can encode Google, Microsoft, Red Hat or your own editorial rules and run them locally, in editors, or in CI.

textlint has 3.2k+ stars and does something similar for natural language: treat prose more like code, with pluggable rules that can flag problems before the text ships.

retext-readability checks whether prose is actually appropriate for the intended reader using several established readability measures, while retext-simplify catches needlessly complicated phrases such as using “utilize” where “use” works.

write-good has 5.1k+ stars and catches things like unnecessary wording, weak modifiers, passive constructions and weasel words. Simple, deterministic checks are useful after the agent has done the semantic writing work.

The stack I find interesting is:

reader + task
     ↓
Agent Stylebook
     ↓
LLM writes
     ↓
Vale / textlint / retext
     ↓
clearer output

The point is not to make every model write in the same stripped-down style. It is to stop treating writing style as decoration.

For agents, writing style is part of the interface between the model and the person trying to understand its work.

Pick the writing system before the model picks one for you.

Models evolve quickly, but our saved skills often stay unchanged.

A SKILL.md written months ago captures more than a workflow. It can also capture assumptions about what the model needs explained, where it makes mistakes, and how tightly it needs to be guided. [Github]

When the model changes, those assumptions deserve another look. Some instructions remain essential. Others may cause unnecessary reading, repeated checks, or rigid behavior. Simply shortening everything risks throwing away the expertise the skill was supposed to preserve.

That’s the problem I’m exploring with Skill Adapter: adapting existing skills for a target model while keeping their purpose and method intact.

It creates a separate adapted package and explains the changes. The original stays untouched. A valid outcome is “this skill doesn’t need changing.”

The first version includes profiles for Astra, Claude 5 generation, and Kimi K3. Kimi’s guidance is conservative; I don’t yet have evidence for a K3-specific rewriting advantage.

The MIT repo includes the prompts, outputs, and reproduction scripts.

How do you maintain your agent instructions as models change: revisit them regularly, wait until something breaks, or keep one version across models?

ICLR 2027 already crossed 62k registered abstracts.

Not final valid submissions, but still a good reminder that research is becoming a pipeline problem too: literature, writing, formatting, submission, self-review, and peer review.

These open-source projects cover different parts of that stack.

Turn raw research material into a paper draft PaperOrchestra has 139+ stars and comes from Google Research. It takes ideas, experiment logs, and other pre-writing material, then splits the work across agents for outlining, literature synthesis, section writing, refinement, plots, and LaTeX output.

Build an evidence-grounded literature review Literature Review Agent has 117+ stars and searches arXiv + Europe PMC, screens papers, builds evidence cards, and writes only from the corpus you explicitly provide. Useful if you want a review where claims remain traceable back to actual sources.

Generate a first draft while checking citations OpenDraft has 450+ stars and uses 19 agents for research, outlining, writing, citation checking, and export. Its useful twist is verifying candidate DOIs against CrossRef, OpenAlex, and Semantic Scholar before keeping them.

Clean your LaTeX before arXiv submission arxiv-latex-cleaner has 7k+ stars and removes unused files, comments, auxiliary files, oversized images, and other things that should not be in the final arXiv package.

Stop OpenReview mistakes before deadline night OpenReview Agent is a small but useful submission tool that inspects author IDs, metadata, venue fields, attachments, declarations, and transfer payloads before writing anything. It is dry-run-first, which is exactly what you want around a live submission.

Review the paper before the reviewers do OpenJudge has 770+ stars and includes a paper-review pipeline for correctness, novelty, quality, critical errors, and BibTeX verification across sources such as CrossRef, arXiv, and DBLP.

Simulate a multi-agent reviewer panel Open ScholarPeer has 20+ stars and implements a 7-stage review process: summary, literature search, historical context, baseline checking, criterion-specific Q&A, and final venue-formatted review.

With submission volume exploding, the valuable tools are probably not the ones that generate the most text.

They are the ones that help you catch unsupported claims, missing baselines, fake citations, formatting mistakes, weak evidence, and submission errors before a human reviewer sees them.

AI coding agents can now write code much faster than most of us can review it.

A useful pattern is adding a second pass before the PR exists: diff the branch, let another agent inspect it, fix the important findings, then push.

Here are 5 open-source projects for that.

Run a full AI review against a local branch PR-Agent has 13.1k+ stars. Its Local Git Provider can compare branches without a hosted PR, then run its review workflow against the diff. Useful if you want something mature with configurable review categories and broad model support.

Make one agent write and another agent judge The Pair has 360+ stars and runs two agents: an Executor that edits code and a read-only Mentor that plans, reviews, and cross-checks the result. It works with Claude Code, Codex, Gemini, OpenCode, and others.

Put repo-specific rules directly into the review loop Saguaro has 25+ stars and runs locally inside Claude Code, Codex, or Cursor. You can encode rules for your own codebase, then have the agent catch violations while the implementation context is still fresh.

Fan the same diff out to several reviewers local-review has 18+ stars and sends your Git diff to whichever authenticated coding agents or local models you choose. Claude might catch one issue, Codex another, and Ollama can keep the whole review offline.

Get a GitHub-style review without opening GitHub Staff Review is a newer project that opens any local diff in a browser and lets an AI agent leave inline comments. You can resolve findings, rerun the review, and repeat until a fresh pass finds nothing important.

The workflow I like is:

coding agent writes feature
        ↓
tests + lint
        ↓
independent AI review
        ↓
fix findings
        ↓
review again
        ↓
open PR
        ↓
human reviews something cleaner

The important bit is independent review.

Asking the same agent that wrote the code, in the same context, “did you make any mistakes?” is not much of a review process. Give the diff to another agent, another model, or at least a constrained review pass with different instructions.

A huge context window is useful, but dumping everything into it is not.

Coding agents waste tokens on giant logs, irrelevant files, repeated repo reads, and oversized tool outputs. These 6 repos attack that problem from different angles.

Filter terminal noise RTK has 81k+ stars and trims output from tests, Git, Docker, package managers, logs, and other CLI tools before it reaches the agent.

Compress tool traffic Headroom has 73k+ stars and compresses tool results, logs, files, RAG chunks, and conversation history while keeping the full data retrievable.

Package a repo cleanly Repomix has 28.5k+ stars and turns a codebase into an AI-friendly bundle with filtering, structure, and token counts.

Control exactly what enters the prompt Code2Prompt has 7.7k+ stars and lets you include only the files, diffs, and directories you actually want the model to see.

Search the codebase instead of rereading it Code Context Engine has 400+ stars and builds a local code index so agents can retrieve relevant symbols and snippets on demand.

Teach the agent to use less context on purpose AI Cost-Cutter Skills has 18 stars and includes a context-diet skill for coding agents that repeatedly reread the same files. The pattern is simple: index once, retrieve only the relevant pieces, and measure whether token use actually drops. The repo also has skills for routing, reasoning-effort throttling, and cost auditing.

A practical stack could look like:

search the repo
    ↓
pull only relevant code
    ↓
trim noisy command output
    ↓
compress the rest
    ↓
leave more context for reasoning

The point is not to make the agent read less. It is to make sure the tokens it reads are the ones that actually matter.

Jev has only been out for a little over a week, and an entire mini-ecosystem is already forming around the idea.

The common pattern is simple:

state
  ↓
typed questions
  ↓
probabilities
  ↓
ordinary code decides what happens

No paragraph generation. No JSON repair loop. Just fast decisions like route / retry / escalate / reject / continue.

Here are 8 newer OSS projects exploring that idea.

Run a fully open System One model locally Laya has 18.8k+ stars and uses small bidirectional models instead of an autoregressive LLM. It supports choice, score, and yes/no decisions, includes multilingual checkpoints, and exposes a Jev-compatible /v1/systemone endpoint.

Run that same idea natively on a Mac Laya-MLX has 5.7k+ stars and ports Laya to MLX. On Apple Silicon it reports roughly 7–14 ms for short decisions, entirely local with no cloud API.

Train your own Jev-like model Kev has 5.3k+ stars and ships 0.8B, 4B, and 9B models based on Qwen3.5. You get the training code, evals, weights, and the same choice / score / noul API shape as Jev.

Try another small non-generative decision model Von has 500+ stars and uses a ~395M-parameter ModernBERT-style model for local typed decisions. It also exposes a Jev-compatible server, so an app can swap between implementations without rewriting the decision layer.

Turn almost any LLM into a Jev-style decision engine AnyJev comes from Nokia Applied Research. Instead of training a new model, it reads next-token probabilities from existing models and converts them into choice, score, and yes/no decisions, with extra corrections for label-position bias and priors.

Re-create the pattern on Qwen3.5 reflex is another open System One experiment. One state goes in, several typed questions come back at once, with probabilities rather than generated prose.

Build a Jev-style model on Gemma system-one-open uses Gemma models and trains them for the same one-forward-pass typed-decision pattern. It includes demos for support tickets, invoices, security, smart homes, and agent traces.

Run decision models directly in the browser open-jev takes the idea into TypeScript + WebGPU/WASM. It can run Kev and other open decision models on-device, which makes things like local routing, moderation, or classification possible without sending the input to a server.

What I find interesting is that these projects are not just cloning an API.

They are testing different answers to the same question:

>Do we really need a full generative LLM every time software needs to make a fuzzy decision?

The decision model handles the hot-path branches.

But the Jev launch seems to have triggered something useful, people are now experimenting with decision models as their own layer, instead of treating every AI problem as text generation.

Code migration is one of those jobs where AI agents actually make a lot of sense.

Here are 7 open-source projects worth knowing.

Give Claude Code a migration playbook: code-migration-kit-with-claude-code has 410+ stars and is Anthropic's new reference kit for large language-to-language migrations. It covers feasibility, dependency mapping, a migration rulebook, pilot translations, parallel agents, compilation, and behavioral parity.

Run structural rewrites across millions of lines ast-grep has 16k+ stars and searches the syntax tree rather than raw text. So instead of replacing every occurrence of a string, you can describe the actual code pattern you want changed.

For example:

old API call
    ↓
match only real calls in the AST
    ↓
rewrite them to the new API

Much safer than regex when a migration touches thousands of files.

Do large Java/framework migrations with recipes OpenRewrite has 3.7k+ stars and is built specifically for automated mass refactoring. Its ecosystem includes recipes for things like Java upgrades, Spring migrations, JUnit 4 → 5, Jakarta namespace changes, and dependency modernization.

Migrate JavaScript projects to TypeScript ts-migrate from Airbnb has 5.6k+ stars. Give it a JavaScript or partially migrated project and it tries to get you to a compiling TypeScript codebase first, leaving weaker any types and @ts-expect-error markers for cleanup afterward.

That is a useful migration strategy in itself: get the whole system across the boundary first, then improve type quality incrementally.

Write reusable migrations without thinking directly in AST nodes GritQL has 4.6k+ stars. You write code-shaped patterns such as:

console.log($msg)
        ↓
winston.log($msg)

and then add conditions as the migration gets more complicated. It supports multiple languages and is designed for migrations that start simple but eventually need real structural logic.

Build JavaScript/TypeScript codemods jscodeshift has around 10k stars and remains one of the classic tools for programmatic code migrations.

Framework authors use this pattern a lot: an API changes, they publish a codemod, and users transform thousands of call sites instead of manually editing them.

Automate the dependency side of migration Renovate has 22.5k+ stars. It is best known for dependency update PRs, but that becomes part of almost every long-running migration: move package versions, replace deprecated dependencies, update lockfiles, and keep upgrades coming in controlled batches.

The agent should not manually improvise its way through 50,000 files. Give it a map, a rulebook, deterministic transformation tools, and a test that tells it when the new system behaves like the old one. Then let the agent handle the messy exceptions.

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.

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.