GitHub Trending Top 10: PDF inspection, agent memory, and low-VRAM inference (Aug. 2–9) (2026)

The Aug. 2–9 chart is more practical than last week’s collection of rooms, worlds, and mesh protocols. It starts with a Rust PDF parser, moves through security and agent memory, then drops into low-VRAM inference, long-running coding agents, project management, and shell-native multi-agent work. The common thread is packaging: each repository takes a messy capability and gives it an interface an engineer can install, inspect, or reuse. 1

Coverage: Aug. 2, 2026 at 20:00 through Aug. 9, 2026 at 20:00 Eastern Time. Rank and weekly star growth are a snapshot of GitHub’s weekly page captured at the publication boundary, not a permanently auditable seven-day time series. Repository API snapshots below are separate captures for current stars, open issues, push dates, and licenses, so small differences are normal. 1

The chart at a glance

Rank	Repository	Language	Stars	Stars this week	License
1	firecrawl/pdf-inspector 2	Rust	13,875	8,641	MIT
2	zhaoxuya520/reverse-skill 3	PowerShell	22,515	9,784	MIT
3	TencentCloud/TencentDB-Agent-Memory 4	TypeScript	18,762	8,003	NOASSERTION*
4	lyogavin/airllm 5	Jupyter Notebook	30,374	5,129	Apache-2.0
5	esengine/DeepSeek-Reasonix 6	Go	33,449	4,709	MIT
6	microsoft/AI-For-Beginners 7	Jupyter Notebook	64,034	5,514	MIT
7	usekaneo/kaneo 8	TypeScript	7,903	1,952	MIT
8	virgiliojr94/book-to-skill 9	Python	19,442	4,121	MIT
9	google/skills 10	Python	17,224	1,626	Apache-2.0
10	unclebob/swarm-forge 11	Clojure	2,052	562	Not declared

* GitHub’s API returned NOASSERTION for TencentDB Agent Memory, while the README says MIT; treat the repository’s licensing files as the authority before redistribution. 4 12

1. firecrawl/pdf-inspector

PDF tooling usually makes a bad first decision: send every document through OCR or hand the entire file to a general parser. pdf-inspector instead classifies the document as text-based, scanned, image-based, or mixed, then extracts native text with coordinates and layout information. That makes it a routing layer for ingestion pipelines, especially when scanned pages should go to OCR and native text should stay local. 2

The implementation is a Rust core built on lopdf. It parses a document once, then separates detection, extraction, table handling, and Markdown cleanup. The extractor tracks fonts, content streams, Form XObjects, links, fields, columns, and reading order. Python bindings use PyO3, Node bindings use napi-rs, and browser builds use WebAssembly, so the same parser can sit inside a CLI, a server, or a browser workflow. The repository also documents tests, CI, examples, and a 200-PDF benchmark corpus. 2

Its edge over a generic pdftotext wrapper is the explicit confidence-aware classification and the ability to emit structured Markdown, including tables. Its boundary is equally important: scanned and badly encoded files still need an OCR fallback. The API snapshot shows 118 open issues, 12 contributor accounts, a push on Aug. 9, and MIT licensing. 13 14

Verdict: star it if you build document pipelines or want a clean native-text/OCR split. Skip it as a universal PDF solution; the OCR boundary is not optional.

2. zhaoxuya520/reverse-skill

reverse-skill is a routing system for authorized reverse engineering and security research. Its useful contribution is not another collection of shell commands. It gives an agent a decision path for APKs, binaries, encrypted JavaScript, malware, firmware, API security, CTFs, and penetration testing, then records scope, evidence, findings, and handoffs instead of letting the model improvise a toolchain from scratch. 3

The core is configuration-driven PowerShell and Markdown: RULES.md gates actions, MASTER-ROUTING chooses a primary path, case initialization creates scope and timeline files, and scenario skills connect the task to tools such as Ghidra, IDA, radare2, Frida, Burp Suite, and MCP servers. The repository lists 41 routing rules, 163 regression cases, 42 modules, cross-platform scripts, and GitHub Actions checks on Windows and Ubuntu. It is designed to stay client-neutral while offering adapters for Claude Code, Codex, Cursor, OpenCode, and others. 3

Compared with a static prompt pack, this treats security work as a controlled workflow with evidence and supply-chain checks. The cost is maintenance: the tool index, client adapters, and many external prerequisites must stay coherent. It also needs a careful authorization boundary; the repository’s intended use is not a license to probe systems you do not own. The API shows 11 open issues, one contributor account, a push on Aug. 9, and MIT licensing. 15 16

Verdict: star it as a study in safety-gated agent routing. Skip it as a turnkey security platform; the value is in the workflow design and your ability to validate every tool it invokes.

3. TencentCloud/TencentDB-Agent-Memory

TencentDB Agent Memory attacks the part of agent development that disappears between sessions: project decisions, documents, code relationships, and team conventions. It turns those inputs into four reusable assets—Chat Memory, Skill, Wiki, and CodeGraph—and lets a team bind assets to agents or roles through a Memory Hub. The goal is shared context with governance, not merely a vector database attached to one chatbot. 4

The README describes three services—memory-core, memory-hub, and proxy—with layered memory from raw conversation through extracted atoms, scenarios, and long-term profiles. Retrieval combines BM25, vector search, and reciprocal rank fusion; ACLs and fixed bindings decide which assets an agent may use. Wiki pages carry link graphs, while CodeGraph records files, symbols, calls, and impact paths. The project exposes tool discovery and calls through an API and documents integrations for OpenClaw, Hermes, Claude Code, CodeBuddy, and an SDK. 4

That separation of memory types is more interesting than another embedding endpoint: a runbook, a coding graph, and a preference history have different owners and failure modes. The trade-off is operational weight. Wiki and CodeGraph build asynchronously, private-repository support is still being refined, and automatic routing is not finished. The API snapshot shows 591 open issues, two contributor accounts, a push on Aug. 6, and NOASSERTION for the license; the README says MIT, so verify the files in the repository before using it in a distribution. 12 17

Verdict: star it if you are designing team-level agent memory. Do not treat the benchmark claims or the README’s license label as production proof without checking the implementation and licensing files.

4. lyogavin/airllm

AirLLM makes a blunt hardware trade: keep only one model layer, or one sparse-MoE expert, in GPU memory at a time and stream the rest from storage. That lets the project advertise very large-model inference on unusually small GPUs, including a 70B model on a single 4GB card. The practical problem is not model quality; it is getting a model to run at all when the entire parameter set cannot fit in VRAM. 5

The Python package wraps Hugging Face models behind AutoModel.from_pretrained, then decomposes and saves them layer by layer. The README documents prefetching, 4-bit and 8-bit compression, CPU inference, Apple-silicon support through MLX, and examples for Llama, Qwen, DeepSeek, Mistral, Gemma, and other families. The reusable pattern is a storage-backed execution schedule: model size stops being the only hardware gate, but disk I/O becomes part of every token’s economics. 5

That differs from ordinary quantization, which reduces memory but still expects much of the model to remain resident. AirLLM’s cost is latency, disk consumption, model-specific compatibility, and a long dependency chain for some newer models. The API snapshot records 135 open issues, nine contributor accounts, an Aug. 9 push, and Apache-2.0 licensing. 18 19

Verdict: star it if constrained hardware is your problem or you want to study layer streaming. Skip it for interactive, high-throughput serving where I/O latency costs more than another GPU.

5. esengine/DeepSeek-Reasonix

DeepSeek-Reasonix is a Go coding agent built for sessions that keep running after the novelty of a one-shot prompt wears off. It combines a terminal/TUI, desktop app, browser access, and ACP editor integration with plan mode, permissions, a sandboxed workspace, checkpoints, and rewindable progress. Its stated design concern—prefix-cache stability—puts context maintenance on the same level as tool execution. 6

The project ships as a single static binary and keeps providers, tools, agents, and plugins in reasonix.toml. DeepSeek is a preset rather than a hard-coded backend; OpenAI-compatible endpoints can be configured, and a planner can be separated from an executor. MCP servers supply tools and resources, while Extension Protocol v1 sidecars can intercept runtime events and add structured UI. The repository documents checkpoints, task contracts, recovery, ACP, plugins, and a Go SDK, with visible CI and release configuration. 6

Compared with a thin CLI wrapper, Reasonix treats the agent as a long-lived local runtime with state, extension points, and recovery rules. The risk is scope: the API snapshot shows 983 open issues, although contributor activity spans 128 accounts across two contributor pages. It pushed on Aug. 9 and is MIT-licensed. 20 21 22

Verdict: star it if you are building or evaluating persistent coding-agent runtimes. Skip it if you need a quiet, mature tool with a narrow feature surface.

6. microsoft/AI-For-Beginners

AI-For-Beginners is a curriculum repository with a stronger constraint than its star count suggests: it tries to give a learner a map before asking them to pick a framework. The course spans 12 weeks and 24 lessons, from symbolic AI and neural networks through computer vision, NLP, genetic algorithms, multi-agent systems, and ethics. Each lesson pairs reading with executable Jupyter notebooks; some add labs and quizzes. 7

Its implementation is educational infrastructure rather than a software library. Examples touch PyTorch, TensorFlow, Keras, OpenCV, Transformers, CLIP, GANs, and reinforcement learning. The repository includes devcontainer and Binder paths, VS Code and Codespaces guidance, 50-plus language translations, beginner examples, and a GitHub Action for keeping translations current. It deliberately leaves out classic machine learning, business use cases, cloud ML platforms, conversational AI, and deep mathematics. 7

That breadth separates it from a framework-first course, but also limits how far any one topic goes. The API snapshot shows 27 open issues, 73 contributor accounts, a last push on July 21, and MIT licensing. It is a mature map with a long tail of community maintenance, not a current production curriculum for every AI specialty. 23 24

Verdict: star it as a starting syllabus or mentoring aid. Skip it when you need deployment, business cases, or mathematical depth rather than orientation.

7. usekaneo/kaneo

Kaneo is a self-hosted project-management system for teams tired of turning simple work into an administration job. The product keeps the familiar kanban and issue-tracking shape, but adds an important developer-facing entry point: an MCP server that exposes project data to agents through HTTP or a stdio package. The question it answers is whether project state can remain open, inspectable, and automatable instead of locked inside a hosted SaaS workflow. 8

The repository is a TypeScript monorepo with React and Hono, packaged for Docker Compose and split API/web images. PostgreSQL is the default database; advanced deployments have a Helm chart for Kubernetes. The quick start covers a bundled container, while the MCP path is available at /api/mcp or through @kaneo/mcp. That combination makes the system more than a UI: it is a project-state service with a tool boundary an agent can call. 8

Its differentiation from Linear- or Jira-style hosted tools is control over deployment and data, plus the ability to connect an agent without screen scraping. The cost is the usual self-hosting tax: database credentials, an auth secret, client URLs, upgrades, and explicit configuration are yours. The API shows 60 open issues, 87 contributor accounts, an Aug. 9 push, and MIT licensing. 25 26

Verdict: star it if you want self-hosted project state that agents can query. Skip it if your team’s real need is a managed enterprise workflow rather than another service to operate.

8. virgiliojr94/book-to-skill

book-to-skill solves a narrower problem than retrieval-augmented generation: how to turn a technical book into a repeatable working reference for an agent. It extracts a source, creates a front-loaded SKILL.md, and puts chapters, glossary terms, patterns, and a cheatsheet into separate files that the agent can load on demand. The output is an addressable study structure, not a giant prompt containing the whole book. 9

The pipeline has a deterministic Python extractor and a spec-driven generator. It accepts PDF, EPUB, DOCX, HTML, Markdown, reStructuredText, AsciiDoc, RTF, and other formats through tools such as pdftotext, pypdf, Docling, ebooklib, BeautifulSoup, and Calibre. Validation scripts check the generated skill against host rules for Copilot CLI, Amp, and Claude Code; tests and documentation cover architecture, performance, installation, and usage. 9

The advantage over handing an agent a PDF is retrieval cost and repeatability: a question can point to a chapter instead of reopening the entire source. The limitation is legal and technical. The repository ships no book content, warns against redistributing generated skills for copyrighted books, and says a cloud-hosted model still follows its provider’s data terms. The API shows 23 open issues, 19 contributors, an Aug. 7 push, and MIT licensing. 27 28

Verdict: star it if you build agent learning workflows or maintain internal technical playbooks. Skip it for a one-off document question where ordinary search is cheaper.

9. google/skills

Google’s skills repository packages product knowledge for agents that work with Google Cloud and adjacent services. Its subject is broad—GKE, BigQuery, Cloud Run, Firebase, databases, analytics, Vertex and agent tooling, security, identity, monitoring, and more—but the delivery mechanism is selective installation rather than a monolithic manual. 10

The repository contains skill packages under .agents/plugins, .claude-plugin, and skills, plus a Google Cloud data-agent kit with MCP servers. Users can install selected skills through npx skills add google/skills, or add the marketplace to Claude Code, Codex, or Antigravity CLI. The vendor-maintained scope is the important implementation choice: a skill can encode product-specific commands, constraints, and architecture patterns where a generic coding agent would otherwise rely on stale or vague knowledge. 10

Compared with community skill packs, the benefit is first-party product coverage; compared with SDK documentation, the benefit is an agent-ready operational format. The README also says the repository is under active development, and the fetched page exposes no concrete test or CI evidence. The API snapshot records 32 open issues, six contributor accounts, an Aug. 7 push, and Apache-2.0 licensing. 29 30

Verdict: star it if you use Google products with an agent and want a vendor-maintained starting point. Skip it if your stack is not Google-heavy; the breadth becomes noise quickly.

10. unclebob/swarm-forge

SwarmForge coordinates several coding agents with the least glamorous primitives in the list: tmux, shell scripts, Git worktrees, Babashka, and handoff files. Its design assumes that each role should have a visible terminal, a defined prompt, and an isolated worktree, while a shared constitution and operational scripts keep the swarm coherent. That makes the repository a concrete answer to the problem of agents stepping on one another’s branches. 11

The configuration lives in swarmforge.conf; roles have prompt files, the workflow branches define two-, four-, or six-agent packs, and handoffd.bb moves notes and Git handoffs between them. The project is local and transparent: start a branch, run ./swarm, inspect the windows, and stop the swarm by closing its first tracked window. The same explicitness is the differentiator against abstract orchestrators that hide scheduling behind a service. 11

The trade-offs are just as visible. main is documentary rather than runnable, terminal behavior varies by operating system, sleep can interrupt work, and the API snapshot declares no license. It has 18 open issues, three contributor accounts, and a push on Aug. 9. Those numbers do not make it weak; they tell you this is a compact design reference, not a platform with a broad support contract. 31 32

Verdict: star it for shell-native multi-agent coordination patterns. Skip it for production adoption until the license and your terminal/runtime assumptions are clear.

What this week says about open-source agents

The strongest projects here do not compete on model cleverness. They give a difficult capability a boundary that a person or another program can use: pdf-inspector separates native text from OCR; reverse-skill separates scope from action; TencentDB separates memory types and permissions; AirLLM separates model size from VRAM; Kaneo separates project state from its UI; and SwarmForge separates agent roles with worktrees and handoffs.

There are three reusable patterns worth carrying into your own systems:

Route before you spend. PDF classification, security skill routing, and AirLLM’s layer schedule all decide what work is necessary before committing the expensive path.
Make context addressable. Book chapters, memory assets, project records, and checkpoints are useful because they can be loaded, inspected, and replaced independently.
Keep the failure boundary visible. OCR is still required for scans, cloud model terms still matter for generated skills, self-hosting still costs operations, and SwarmForge still depends on terminals and Git semantics.

The best stars this week are bookmarks for different engineering questions. Star pdf-inspector for ingestion, reverse-skill for controlled routing, TencentDB for governed memory, AirLLM for hardware-aware inference, Reasonix for persistent runtimes, and Kaneo for agent-accessible application state. Star the two learning repositories if you want a syllabus rather than a service. In every case, inspect the license, read the failure boundary, and treat a star as a pointer to a design pattern—not a production approval.

참고 출처

1
GitHub Trending weekly pagegithub.com
2
pdf-inspector repositorygithub.com
3
reverse-skill repositorygithub.com
4
TencentDB Agent Memory repositorygithub.com
5
AirLLM repositorygithub.com
6
DeepSeek-Reasonix repositorygithub.com
7
AI for Beginners repositorygithub.com
8
Kaneo repositorygithub.com
9
book-to-skill repositorygithub.com
10
Google Skills repositorygithub.com
11
SwarmForge repositorygithub.com
12
TencentDB Agent Memory API metadataapi.github.com
13
pdf-inspector API metadataapi.github.com
14
pdf-inspector contributorsapi.github.com
15
reverse-skill API metadataapi.github.com
16
reverse-skill contributorsapi.github.com
17
TencentDB Agent Memory contributorsapi.github.com
18
AirLLM API metadataapi.github.com
19
AirLLM contributorsapi.github.com
20
DeepSeek-Reasonix API metadataapi.github.com
21
DeepSeek-Reasonix contributors page 1api.github.com
22
DeepSeek-Reasonix contributors page 2api.github.com
23
AI for Beginners API metadataapi.github.com
24
AI for Beginners contributorsapi.github.com
25
Kaneo API metadataapi.github.com
26
Kaneo contributorsapi.github.com
27
book-to-skill API metadataapi.github.com
28
book-to-skill contributorsapi.github.com
29
Google Skills API metadataapi.github.com
30
Google Skills contributorsapi.github.com
31
SwarmForge API metadataapi.github.com
32
SwarmForge contributorsapi.github.com