Changelog

Local-first work receipts for coding agents: reads the session logs Claude Code, Codex, OpenCode and Hermes already write and reports what each task did, what it cost, and whether a check proved it.

Speculative programmatic tool calling: while the model is still streaming a code block, the harness launches the tool and sub-LLM calls it is about to make, so blocking calls overlap generation.

Neo4j Labs' semantic layer for data agents: ingest warehouse schema, business glossary, metrics and query history into one graph, then serve it over MCP so agents route queries and write grounded SQL.

Embedded single-file graph database in Zig: graph traversal, HNSW vector search and BM25 full-text in one query language, plus a durable event log — built for Graph RAG and local agent memory.

Benchmark plus memory pipeline for stale memories: STALE probes whether agents notice stored facts stopped being true; CUP-Mem adds conflict-aware writes, invalidation and premise verification.

Executor–verifier orchestration for code changes: a conductor classifies the task, an executor works in an isolated worktree, and a separate verifier must reproduce the evidence — looped to approval.

Real-time global situational-awareness dashboard: curated feeds AI-synthesized into briefs over a 3D globe, cross-stream correlation and a country instability index — plus MCP, REST API and CLI.

General-purpose local AI agent in Rust — native desktop app, full CLI and embeddable API — over 15+ providers and 70+ MCP extensions. Block's goose, now an Agentic AI Foundation project.

Cross-harness session memory: hooks capture what the agent does, an LLM compresses it into observations, and the next session gets the relevant ones back via progressive-disclosure MCP tools.

Context-waste hunter for coding agents: hooks compress reads, bash and search output, checkpoint before compaction, and audit waste in configs, skills, MCP and memory — with a local dashboard.

Persistent-agency agent harness in ~10K lines of Bash: it keeps thinking between messages, thinks by writing shell commands, and one shared mind serves a whole team over Slack or Telegram.

Zero-trust P2P mesh for agents, published by Google: libp2p nodes with portable crypto identities self-discover, and an MCP sidecar lets an agent invoke tools on any node — cloud, local or edge.

Chrome extension running a Planner/Navigator multi-agent loop inside the browser you already use, with your own API keys — a free, local alternative to OpenAI Operator.

Self-hosted Java agent platform: ReAct plus plan-and-execute 'digital employees' with an LLM Wiki knowledge layer, skills/MCP/ACP tools, approval-gated actions and eight IM channels in one JAR.

Edge-native MoE serving engine: bandwidth-adaptive CPU-GPU co-execution, global LRU expert caching and elastic VRAM run 290B+ frontier MoE models on a gaming PC at interactive speed.

MCP server that lets a coding agent build and query a typed concept graph of the project — SQLite store, in-process embeddings, merge-conflict resolution and a local web graph explorer.

Rust long-term memory server for coding CLIs: lifecycle hooks capture sessions into a sanitized shared wiki, then hand a bounded summary to the next agent so Codex can resume what Claude Code started.

Datalab's 39k-star PDF-to-Markdown/JSON converter: a layout pipeline plus an optional LLM pass for tables, forms and equations, with chunk output and form-value extraction built in.

Declarative LLM extraction from documents: describe Aspects and Concepts in plain language, get structured values back with paragraph- or sentence-level references and built-in justifications.

NVIDIA's object-oriented agent framework: an agent is a Python class — fields are state, docstrings are prompts, and a `...` method body becomes an LLM loop that acts by writing Python.

Perplexity's endpoint sensor for AI agents: hooks, OTLP logs and on-disk session artifacts normalized into one CEL-matched event model, with opt-in pre-action blocking and offline forensics.

Trace-native CI/CD for agents: OTLP traces are graded on arrival, failures cluster into issues, and one click freezes a failing run into a hermetic regression case that blocks the PR.

A 45M-parameter tool-calling model shipped as one 14MB binary that runs a full session in ~28MB RAM — grammar-constrained JSON, calibrated confidence, tool retrieval, LoRA fine-tuning.

Graph-engineering runtime where TypeScript owns control flow and replaceable coding-agent CLIs — Codex, Claude Code, Pi — do the semantic work inside each node. Pilot for DeerFlow 3.0.

antirez's C/Metal engine running MiniMax-H3 video and audio generation natively on Apple Silicon — interactive prompting, 4-step schedules, SSD block streaming down to ~2 GB DiT residency.

Native macOS menu-bar front-end for CLIProxyAPI: pool your Claude, Codex, Qwen and Copilot accounts behind one local proxy with live quota bars, auto-failover and one-click CLI wiring.

Cross-platform on-device AI toolkit: run LLMs, ASR and TTS natively from Flutter, Unity, Kotlin, Swift or Rust on a llama.cpp and ONNX Runtime core. Private, offline, no cloud.

Agent skill plus local service that strips AI provenance marks: invisible Unicode and bidi characters, statistical text watermarks, and C2PA/EXIF/XMP metadata across 20+ file formats.

The IDE for your coding agent: an MCP toolkit giving symbol-level retrieval, editing, refactoring and debugging over real language servers — or a JetBrains plugin backend.

Agentic ontology-assisted RDF extraction: co-evolves domain ontologies and fact graphs in a map/reduce pipeline with RDF 1.2 provenance, entity disambiguation and SHACL autofix.

Uncle Bob's strategy as a skill: the agent writes a SPEC you approve, then runs a gauntlet — tests, mutation, property-based, coverage, supply chain — and hands you an evidence report instead of code.

Semantic DataFrames: PySpark-style select, filter and join alongside AI operators — extract, classify, summarize, embed, semantic join — compiled on an engine built for inference.

Self-hosted ETL/ELT on DuckDB: author pipelines on a canvas, in SQL or Python, then ship the same file to your own server — 190+ sources, dbt, CDC, lineage, and an MCP server for agents.

docTR: two-stage OCR in PyTorch — detect words, then recognize them — with pretrained detection and recognition architectures you can mix, plus layout detection and rotated-page handling.

Documents to validated knowledge graphs: Docling parses, an LLM or VLM fills Pydantic schemas, and you get a directed NetworkX graph with provenance, Cypher/CSV export and HTML views.

DeepSeek's open agent harness (`dsh`): everything is a plugin, on the Cordis composability runtime, with a local web UI one npx away. Developer preview, MIT, moving fast.

Zeron: control Claude Code, Codex, Cursor, Grok, Hermes and Pi from a local Rust daemon — sessions live on the device, with optional sign-in to drive them from another machine.

Run MoE models bigger than your RAM: keep the always-needed weights resident and stream each token's experts from flash — a 284B model on a 12 GB phone, CPU only, byte-identical output.

An open spec for Markdown vaults as linked data: YAML-LD frontmatter plus a shared @context makes notes an RDF graph, with reference scripts that round-trip vault to Turtle and back.

TrueFoundry's open agent harness: the runtime loop — model calls, MCP tools, SKILL.md packs, sandboxing, approvals, compaction — behind a chat UI, HTTP API, TypeScript SDK and embeddable UI.

Agentic observability for OpenTelemetry: ingest traces, logs and metrics, group noisy signals into incidents, then let pluggable agent runners investigate while you sleep. Self-hosted, open-core.

Andrew Ng's local-first desktop AI coworker: give it an outcome and it works across your files, terminal and 25+ apps — Slack, Jira, Notion, Gmail — then hands back the finished deliverable.

Topic in, finished short out: an LLM writes the script, footage comes from Pexels/Pixabay or text-to-video, then TTS, subtitles and music compose into HD 9:16 or 16:9. WebUI, API and CLI.

A living wiki for your codebase, written by your coding agents: a Tree-sitter graph grounds structured Markdown notes, task-aware routing loads only what's needed, and drift checks catch stale claims.

One portable memory layer for every agent: conversations, files and trajectories kept as canonical Markdown, indexed locally by SQLite and LanceDB, with offline reflection that refines them.

AWS's ontology-based context layer: scan your sources, induce ontologies, then serve validated context to agents over MCP — SPARQL federation, a virtual knowledge graph and OWL reasoning.

Mock everything an AI app talks to: 13 providers across 15 API surfaces plus MCP, A2A, AG-UI, vector DBs, search and rerank on one local port — with record-and-replay fixtures.

Volcengine's context database: memories, resources and skills as one `viking://` filesystem agents ls, tree and grep — L0/L1/L2 tiers, traceable retrieval, sessions distilled into memory.

Write HTML, get MP4: HeyGen's agent-native video framework renders deterministic GSAP/Puppeteer/FFmpeg compositions, shipping 20 skills and MCP so coding agents author motion graphics.

Microsoft's AI data-visualization workbench: connect files, DBs or Databricks, ask in plain language, and agents write the transforms behind 30+ chart types you branch and restyle.

Turns buildings, streets, GTFS/GBFS feeds and origin-destination flows into spatial heterogeneous graphs, round-tripping GeoDataFrames, NetworkX and PyTorch Geometric for GNNs.

Neo4j Labs' graph-native agent memory: conversations, a POLE+O entity knowledge graph and reasoning traces in one store, with a 16-tool MCP server and hosted or self-hosted backends.

RL framework for training reasoning-and-search interleaved LLMs — the open recipe behind DeepSeek-R1-style search agents: PPO/GRPO on veRL, any search backend, models and data on HF. Two papers.

Local trading workspace that makes coding agents into trading agents: git workspaces, markdown issues, an Obsidian-like memory graph, market tools and approval-gated trading primitives.

Python package bridging deep learning and geospatial data: train and apply classification, detection and segmentation models on satellite and aerial imagery. JOSS paper, conda-forge, QGIS plugin.

Production JavaScript framework for agentic workflows: one sentence becomes a dependency-aware multi-agent plan that runs in browser, Node, or extension — with pause/resume and snapshot recovery.

Claude Code skill that turns any code — AI-generated, legacy, or unfamiliar — into educational deep dives or senior-level architectural audits, tuned by skill level and token budget.

A skill file that removes AI tells from prose: ~30 banned phrases across 7 categories, 8 banned structural patterns, and a 50-point scoring rubric that forces revision below 35. Zero dependencies.

Desktop app that records a real work session — clicks, apps, pages, narration — and uses Copilot CLI to reconstruct intent + steps, then generates a reusable SKILL.md or scheduled Automation.

Self-hosted autonomous pentesting: multi-agent system in sandboxed Docker with 20+ tools, supervised agent hierarchies, Langfuse observability and a Graphiti knowledge graph. 10+ LLM providers.

Self-hosted platform orchestrating AI agents for vulnerability research: chain focused prompts into reusable workflows, run them in parallel over Codex or Claude Code, dedupe and rank findings.

Multimodal retrieval engine for visually rich documents: ingestion, visual-first search over charts, tables and diagrams, knowledge graphs and cache-augmented generation — one engine, not a pipeline.

Portable agent skill that strips the signs of AI-generated writing — 25 pattern categories from Wikipedia's 'Signs of AI writing' guide, with a two-pass self-critique loop and voice calibration.

Self-hostable platform for the whole agent-quality loop: tracing, evals, simulations, datasets, guardrails and an LLM gateway — one feedback loop from prototype to production. Apache 2.0.

Self-hosted private AI workspace: chat, multi-agent crews with human review, a visual workflow builder and Telegram integration in one app — local models via Ollama/llama.cpp or your own keys.

File-based durable memory for coding agents: brain-setup scaffolds a BRAIN.md protocol + brain/ directory of decisions, requirements and constraints — plain Markdown in your repo, written via CLI.

76 production-ready Claude skills across frontend, backend, DevOps, security, cloud and AI/ML — with a Skillchain workflow system that chains them into guided full-stack builds. 19 plugin groups.

Meetings as live agent loops: local recording, dual-channel you-vs-them transcription, in-call AI suggestions, auto-triggered MCP tools mid-conversation, and post-call summaries. macOS/Windows.

All-in-one server and WebUI for generative image and video — Stable Diffusion and dozens of model families, with captioning, upscaling and processing pipelines. Cross-platform, API-first.

Turns any technical book PDF — or folder of sources — into a structured agent skill: mental models in SKILL.md, per-chapter files loaded on demand. Claims 24-51x fewer tokens than context-dumping.

Graph-native context infrastructure for accountable AI: ingest enterprise data, extract a knowledge/context graph (RDF + LPG), run graph analytics and causal reasoning with decision provenance.

Terminal coding agent optimized for low-cost open models — a Rust Codex fork with switchable harness emulation (claude-code, kimi-code, qwen-code…), ACP support and Codex SDK compatibility.

Open metadata platform turned AI context layer: 130+ connectors feed a unified knowledge graph of lineage, quality, ownership, glossaries and contracts — served to agents via MCP and APIs.

Self-hosted enterprise knowledge hub + MCP server: an LLM pipeline compiles SOPs and docs into a traceable, human-reviewed wiki, then serves it to AI clients scoped by department and role.

Rust library converting Word, PowerPoint, Excel, OpenDocument, RTF, EPUB, CSV and PDF to clean Markdown in single-digit milliseconds — Node/Python/WASM bindings, CLI, and an agent skill.

Virtual filesystem for agents inside a Cloudflare Durable Object — SQLite-authoritative state with pluggable execution: FUSE-mounted containers, isolate shell (just-bash) or isolate JavaScript.

Self-improving coding/research agent around a Recursive Language Model: persistent IPython as the core tool, programmatic subagents, durable harness state it refines via evidence-backed /refine.

Fine-tune and post-train LLMs from one YAML: QLoRA, DPO/ORPO/SimPO/KTO — layer streaming trains an 8B model in 3.3GB VRAM on a laptop GPU, bit-exact against a resident run.

Ten agent skills for solopreneurs — SEO/GEO, Reddit/X/Product Hunt research, domain hunting, logo and banner generation, session archiving — installable in Claude Code, Cursor and 16+ tools.

Reverse-engineering and pentest skill router for coding agents: routes APK/ELF/JS/PCAP/CTF tasks to the right playbook, bootstraps jadx/Frida/IDA-class toolchains, evolves a knowledge base. CN/EN.

State-machine guardrails for AI agents: define workflow phases once and only that phase's tools unlock — enforced across Claude Code, Codex, Cursor, opencode and Pi. Rust.

All-in-one AI framework around an embeddings database — dense, sparse, graph and relational fused — with pipelines, workflows, agents and MCP/web APIs. Python, bindings for JS/Java/Rust/Go.

Indexes the session histories your coding agents already wrote — 17 harnesses, months retroactive — and serves recall over MCP. 84.9% hit@1 on LongMemEval-S, no LLM, no embeddings. One Go binary.

Rust MCP server + desktop Studio for AI-native ontology engineering: 70+ tools over an in-memory Oxigraph store — OWL2-DL tableaux reasoning, SHACL, SPARQL, versioning. Single binary, no JVM.

One installer that turns a PC, Mac or Linux box into a private AI server: Ollama, Open WebUI, n8n, ComfyUI wired together — inference, chat, voice, agents, RAG and image gen, no cloud.

PostgreSQL extension adding graph search, traversal and shortest-path over your existing tables — a derived graph index queried from plain SQL, no separate graph DB or query language. Rust.

Code-intelligence engine in one static Go binary: tree-sitter graph over 257 languages, compiler-grade resolution for 17, multi-repo, 175 configurable MCP tools — up to 50x fewer tokens. 100% local.

IBM's registry + proxy federating MCP, A2A and REST/gRPC into one governed endpoint: discovery, auth, rate limits, guardrails, OTel tracing, 40+ plugins — scales to K8s with Redis federation.

Distributed graph issue tracker for coding agents on Dolt: dependency-aware beads replace markdown plans — bd ready/claim/close, cell-level merge, push/pull across machines and agents. CLI + MCP.

Agentic formal verification: coding agents write TLA+ specs and invariants of your distributed system, model-check them, and reproduce violations at code level. arXiv paper + public bug list.

Modular local voice-agent pipeline — VAD→STT→LLM→TTS behind an OpenAI Realtime-compatible WebSocket; every stage swappable, the LLM slot takes any OpenAI-compatible server. Powers Reachy Mini robots.

Turns Databricks Unity Catalog tables into a materialized knowledge graph: OWL ontology design, R2RML mapping, OWL 2 RL/SWRL/SHACL reasoning, auto-generated GraphQL — exposed to agents over MCP.

GPU document parser in C++/TensorRT: PP-OCRv6 OCR, layout, tables and formulas to Markdown at 200-559 img/s on one GPU — no VLM, HTTP + gRPC, one-line Docker deploy.

Skill memory layer for agents: auto-captures learnings from runs into plain Markdown skill files you can read, edit, git and share across frameworks — memory without an opaque store.

One CLI gives agents read/search access to Twitter, Reddit, YouTube, GitHub, Bilibili and XiaoHongShu with zero API fees — multi-backend routing the maintainers repair when platforms break.

Parses a polyglot monorepo with Tree-sitter into a Memgraph knowledge graph: query it in plain English (NL→Cypher), trace data flow, find dead code, edit via AST-surgical patches.

KG-guided synthetic SFT data: builds a knowledge graph from source text, finds the LLM's knowledge gaps via calibration error, and generates targeted long-tail QA pairs. ACL-published.

LLM-driven Python scraping: describe what you want and graph pipelines extract structured data from websites or local docs (HTML, XML, JSON, Markdown). 29k stars; cloud API upsell.

Multiplayer agent harness for startups: every employee gets a scoped workspace — memory, files, keychain, crons, sandbox — in Slack and web, with Pi/OpenCode/Codex/Claude Code swappable underneath.

Rust framework for LLM apps: an agent harness, compile-time-typed task graphs, and streaming RAG pipelines — MCP toolboxes, human-in-the-loop approval, tracing with Langfuse support.

Context layer for large codebases: a graph of plain-English markdown nodes — no embeddings, no index — agents read like any repo file. Claude Code hooks + MCP; 42% fewer tokens in its bench.

LobeChat's 80k-star pivot: from chat UI to 'Chief Agent Operator' — hire, schedule and supervise a team of agents running 7×24, self-hosted via Docker or Vercel, plugin ecosystem carried over.

Local-first cost ledger for AI coding: reads the session files 36 tools already write and breaks every token and dollar down by task, model, project. TUI, web, desktop, menubar — no proxy, no keys.

Persistent memory for coding agents on the iii engine: MCP server with 53 tools, 12 auto-capture hooks, hybrid search + knowledge graph, zero external DBs. Claims 95% R@5 and 92% token cuts.

Turns your coding CLI into a job-search command center: scans Greenhouse/Ashby/Lever, scores listings A-F into a 1-5 rubric, tailors ATS-ready CVs, tracks applications. Claude Code, Codex, OpenCode+.

Single-file memory layer for agents: data, embeddings, index and metadata in one portable .mv2 — append-only Smart Frames, time-travel queries, sub-5ms recall, no server. Rust core, Node/Python SDKs.

Rust CLI proxy compressing dev-command output 60-90% before your agent reads it — git, tests, linters, docker, 100+ commands; hooks auto-rewrite bash calls. Single binary, <10ms overhead.

137k-star roster of specialist agent personas — engineering, design, marketing and ops divisions — installable into Claude Code, Cursor, Codex and 13+ tools via scripts or a native desktop app.

Claude Code config pack + optional local harness: TDD-enforcing hooks, 67 skills, quality gates, persistent memory — plus a dashboard routing each task across 13 models by cost-aware blast score.

Spec, task and memory layer that lives in your repo: .trellis/ holds conventions, PRDs and journals, auto-injected each session — one workflow across 20 coding-agent platforms.

YC-backed multi-agent harness for production: state an objective and the runtime compiles a graph DAG of specialized agents — role-based memory, crash recovery, cost limits, human-in-the-loop.

Rust coding-agent harness built for footprint: ~28MB per session vs 140-390MB for Codex/Claude Code, instant boot, optional local embeddings — made for running many sessions in parallel.

Runtime security for AI agents: watches actions AND reasoning traces to catch prompt injection, tool poisoning and out-of-remit behavior — blocking before the action lands. SDKs + Claude Code plugin.

LLM-driven platform turning unstructured documents into structured data: a no-code Prompt Studio to define extractions, then deploy as APIs or ETL pipelines. Self-hosted, AGPL + enterprise.

Graph engineering as a Claude skill: SEU's 9-stage knowledge-graph course (translated) plus task-graph orchestration patterns — with a teaching mode and nine paste-ready /kg workflows.

Self-hosted OSINT terminal: 27 open feeds — satellite fires, flights, radiation, sanctions, markets, conflict data — polled in parallel onto one Jarvis-style dashboard. LLM turns it two-way.

The first open foundation model for financial candlesticks: trained on K-lines from 45 global exchanges, AAAI 2026, weights on Hugging Face with fine-tuning scripts for your own tasks.

Aider woven into Emacs: AI pair programming with intelligent model selection, Ediff for reviewing AI changes, and file management that stays true to Emacs workflows. MELPA-packaged.

HKUDS's skill lifecycle layer for agents: retrieve the right skill per task, evaluate which ones actually work from real outcomes, share across agents and teammates, evolve with every run.

Hierarchical agent loops: nodes iterate toward a goal in their own git worktree and spawn children for subtasks — the tree grows to fit the problem. Hard caps, SQLite run log, live TUI.

Hugging Face's Python port of Pi's minimalist coding agent: a real terminal agent with TUI, sessions and skills — built to be READ, with a clean brain/environment/frontend separation.

Tokenization at GB/s: ~1000x faster than HuggingFace tokenizers with drop-in compatibility modes for HF and tiktoken — Rust reading your files directly. pip install gigatoken.

Agent multiplexer for your terminal: every Claude Code/Codex session in real panes — blocked/working/done at a glance, detach and reattach over SSH, plus a socket API agents drive themselves.

Runnable course: a production OCR pipeline on Kubernetes — Rust ingestion, Qwen 3.5 (4B) served by vLLM at 1.86 pages/s, Redis queues, KEDA autoscaling. Deploy it on AKS/GKE, not a notebook.

OpenAI's GitHub Action for CI hardening: bounded egress filtering and runner lockdown — the fence that keeps supply-chain attacks out and your CI-resident coding agent in.

Vectorless, reasoning-based RAG — builds a hierarchical tree index from long documents so an LLM retrieves by relevance instead of similarity. No chunking, no embeddings, no vector DB.

Rust memory layer for AI agents with Git-style version control — snapshot, branch, merge and rollback over MatrixOne's copy-on-write engine, plus hybrid vector + full-text retrieval.

From-scratch headless browser in Zig for AI agents and automation — CDP-compatible (Puppeteer/Playwright connect as-is) at ~9x the speed and ~16x less memory than headless Chrome.

Small Go HTTP/MCP server that gives AI agents direct control over Chrome — stealth CDP injection, multi-instance orchestration and a real-time dashboard. Local-first, single binary.

ruvnet's 65k-star 'agent meta-harness': multi-agent swarms, adaptive memory and RAG layered over Claude Code, Codex and Hermes — npx ruflo, a UI beta, and a sprawling plugin ecosystem.

The agentic HTML editor: your local coding-agent CLI (9 auto-detected, zero API keys) writes magazine pages, decks, posters and tweet cards via 75 skills — sandboxed preview, 1-click export.

Deterministic PDF parser for AI pipelines: #1 extraction accuracy (0.907) on its public bench, bounding boxes on every element, 0.015s/page — plus the first open PDF auto-tagging for accessibility.

CNCF-landscape sandbox platform for AI agents: multi-language SDKs, unified API, CLI and MCP over Docker/Kubernetes runtimes — coding agents, GUI agents, evals and RL training.

The 100-line agent from the SWE-bench team: >74% on SWE-bench Verified with no tools but bash, no config sprawl — the reference minimal harness, adopted by Meta, NVIDIA and Ramp.

Companion memory agent for 20+ coding agents, built on Moorcheh — its own information-theoretic engine, no third-party vector DB to manage. Runs local (Docker + Ollama, keyless) or on their cloud.

fork() for agent microVMs: children fork copy-on-write from a warm Firecracker parent — 100 KVM-isolated VMs in ~100ms, live-VM branching in ~56ms, portable snapshots from a hub.

Activeloop's shared brain for agent TEAMS: traces from Claude Code, Codex, Cursor & co become reusable skills every teammate's agent can execute — cloud-backed, 25% cheaper on LoCoMo.

The /last30days skill: researches any topic across Reddit, X, YouTube, HN, TikTok and Polymarket in parallel, scores by real engagement, and synthesizes one grounded brief. 50+ agent hosts.

Firecrawl's Rust PDF triage: classifies text-based vs scanned in ~10-50ms, extracts positioned text and clean Markdown without OCR — routing the ~54% of PDFs that never needed a model.

Roboflow's reusable computer-vision toolkit: one Detections API over any model (YOLO, SAM, transformers), 20+ annotators, zone counting, tracking and dataset tools. 48k stars, MIT.

htop for AI coding agents: every Claude Code, Codex and OpenCode session in one TUI — tokens, context-window %, rate limits, child processes, orphan ports. Read-only, no API keys. Rust.

Apple's official Core AI toolkit: recipes exporting Hugging Face models to .aimodel, PyTorch primitives for authoring, Swift runtime for macOS/iOS apps — plus skills for coding agents.

Rust 'software factory' for coding agents: define the SDLC as a graph, agents execute it through verification gates, you intervene only at the stages that matter. Server, runs board, sandboxes.

The 74k-star LLM-native crawler: turns any site into clean, RAG-ready Markdown — adaptive crawling, JS rendering, extraction strategies, Docker deploy. Python, Apache-2.0.

Code intelligence MCP in pure C: tree-sitter knowledge graph over 158 languages, average repo indexed in milliseconds, sub-ms queries, 10x fewer tokens. Single static binary, zero deps.

PM Skills Marketplace: 68 skills and 42 chained workflows in 9 plugins — discovery, strategy, PRDs, launch, growth — encoding Torres/Cagan-style frameworks for Claude Code and Cowork.

A skill that makes your agent code like the laziest senior dev: YAGNI enforced — ~54% less code, ~20% cheaper, ~27% faster on measured Claude Code sessions. Works with 20 agents.

Zilliz's unified memory for coding agents: one Markdown + Milvus store shared across Claude Code, Codex, OpenCode and OpenClaw — hybrid search, plus repeated workflows distilled into skills.

Self-improving loop from the SIA paper: Meta, Target and Feedback agents evolve a task agent's harness AND weights against a benchmark — #1 on MLE-Bench Hard, 14x kernel speedups.

The full LLM pipeline hand-written in plain PyTorch — tokens, transformer, pretraining, then SFT, reward model, PPO, DPO, GRPO. No trl, no peft: read every algorithm, train on one GPU.

AST-based semantic code search for coding agents: pipx install, zero config, local embeddings out of the box — a CLI/skill/MCP that cuts agent context ~70% vs grepping. Built on CocoIndex.

Alibaba's battle-tested AI code-review CLI: deterministic pipelines + LLM agent, line-level comments, tuned rulesets (NPE, XSS, SQLi) — higher precision than general agents at ~1/9 the tokens.

Learning loop for any agent: reflect on failures, distill strategies into a Skillbook, inject them next run — 2x consistency on Tau2, 49% token cuts. LiteLLM-based, 100+ providers.

Pytest for LLM apps: 40+ research-backed metrics — G-Eval, RAG suite, agent task completion, hallucination — as unit tests you run in CI, judged by any LLM including local ones.

Context compression layer for agents: squeezes tool outputs, logs, files and RAG chunks 20-95% before the LLM — reversible, local-first; library, proxy, one-command agent wrap, or MCP.

Self-hosted NotebookLM alternative: multi-modal sources, vector plus full-text search, context-aware chat and multi-speaker podcast generation — 18+ model providers incl. Ollama, full REST API.

Karpathy-style autoresearch on any codebase: /evo:discover instruments the benchmark, /evo:optimize runs tree search with parallel subagents in worktrees. Plugin for Claude Code, Codex & co.

Native Mac app for on-device LLM fine-tuning via mlx-lm-lora: pick a model, choose SFT/LoRA/DPO-family algorithms, watch loss fall live, push to Hugging Face. No cloud, no code.

Sudoless Apple Silicon monitor: SwiftUI dashboard plus menu-bar suite tracking ANE, Media Engine and memory bandwidth Activity Monitor won't show — with DVR-style record & replay.

Agent memory that learns, not just recalls: retain/recall/reflect API over Postgres, SOTA on LongMemEval. Self-host via Docker with UI; Python/TS clients, any LLM provider.

Berkeley's visual RAG: render pages and PDFs to screenshot tiles and retrieve with a VLM embedder — tables, charts and layout survive. pixelshot CLI plus a hosted 8.28M-page Wikipedia index.

Push-to-talk offline dictation: hotkey, speak, text lands in whatever field has focus. Whisper or Parakeet fully on-device; cross-platform Rust/Tauri, built to be forked.

Open-source meta-harness over Claude Code, Codex, Cursor, OpenCode, Hermes, Pi and custom agents: swap harnesses without rewriting, enforce policies and sandboxes, follow sessions from any device.

KV-cache layer for scalable LLM serving: offload and reuse KV across GPU/CPU/disk/remote tiers to cut TTFT and prefill cost. vLLM-first; used by NVIDIA Dynamo and llm-d.

Paste a GitHub URL or drop a local folder → interactive architecture map in the browser: dependency graph, blast radius, health grade, security scan. Single index.html, zero install.

Pure-C, zero-dep MoE runtime that runs GLM-5.2 (744B) on a 25GB-RAM consumer box by streaming experts from disk — VRAM/RAM/NVMe as one tiered hierarchy, never touching precision.

Turns any PDF into a fillable form: FFDNet models detect text, checkbox and signature fields; one CLI command writes the interactive PDF. Paper, dataset and weights all open.

AI-native Envoy-based proxy for agentic apps: agent orchestration via a 4B routing model, smart LLM routing, guardrail filter chains and zero-code OTEL traces. Rust, framework-agnostic.

Local-first agentic runtime with persistent AI rooms and approval-gated memory: every memory write needs your OK; rooms, KB and artifacts are plain files on disk.

Open-source GenBI engine: agents write governed SQL and deploy shareable dashboards over 22+ data sources, grounded in a Git-friendly context layer (MDL semantics, definitions, memory).

Distributed LLM inference in Rust: pool GPUs across machines into one OpenAI-compatible endpoint — local fit first, mesh routing, and stage splits for models too large for any single box.

Open-source AI gateway: call 100+ LLM providers in OpenAI format via a Python SDK or self-hosted proxy — with cost tracking, virtual keys, guardrails, load balancing and logging.

ICLR 2026 memory framework for LLMs/agents: LLMLingua pre-compression, topic segmentation and offline memory updates — leading LoCoMo/LongMemEval results at lower token cost.

Anthropic's harness primitives for long-running Claude agents: default-FAIL evidence gates, a fresh-context evaluator subagent and handoff hooks — each one standalone, readable file.

Local-first code intelligence graph for AI coding tools: Tree-sitter AST graph + blast-radius analysis served over MCP, so agents read ~82x fewer tokens per review question.

36k-star hub of runnable AI engineering tutorials — LLMs, RAG and agent apps as self-contained projects, including build-code-harness: a Claude-Code-style coding harness rebuilt on CrewAI + E2B.

Company intelligence agent that navigates Slack, Drive, wiki and CRM live — no ingest/embed pipeline — and builds its own wiki + CRM as it learns your company.

Daniel Miessler's LifeOS: an AI 'life operating system' that carries your goals and context into every task — an intent engineering platform with dashboard, agents and installer.

Structured long-term memory over MCP: an enforced bucket-thread-memo hierarchy in one SQLite file, hybrid FTS5 + vector search fused with RRF, local embeddings.

All-in-one open-source backend for agentic coding: Postgres, auth, storage, edge functions, model gateway and site hosting — your coding agent operates it over MCP.

Local-first desktop workbench for orchestrating coding agents: per-repo workspaces, task dispatch, live status and runnable actions — GUI plus CLI, Apache-2.0.

Turns your coding-CLI subscriptions (Claude Code, Codex, Antigravity, Kimi, Grok) into a local OpenAI/Gemini/Claude-compatible API — multi-account rotation in one Go proxy.

Encrypted secrets store for Claude Code: macOS-Keychain-backed vault with MCP server, CLI, commit-safe secret:// .env placeholders and a native input dialog.

browser-use's thinnest LLM-to-Chrome bridge: all 652 CDP methods as typed JS calls over one WebSocket — no click() helpers, no rails; the protocol is the API.

Persistent, secure sandboxes for AI agents on Firecracker microVMs — TypeScript and Python SDKs, CLI and console; the runtime is a hosted service, the SDK stack is Apache-2.0.

Open-source RAG-as-a-service (the Carbon.ai alternative): upload any data source, get vector search and a chat API in minutes — Supabase-based, multi-tenant with RLS, streaming responses.

Visual workspace to build, deploy and orchestrate AI agents — 1,000+ integrations, knowledge bases, built-in tables and files, schedules and run monitoring. Self-host via npx simstudio or Docker.

Desktop AI coworker (YC S24) that indexes email, meetings and Slack into a living backlinked knowledge graph, then acts on it — email client, browser, meeting notes, background agents, code mode.

A self-hosted personal AI agent in a single ~9MB Go binary — persistent memory, 16 tools + MCP, skills, cron/heartbeat, and Telegram/Discord/Slack/WhatsApp channels. Runs on a $5 VPS.

8 AI agents + 14 skills that run your Obsidian vault through chat — capture, triage, search, linking, vault health, transcription, email and calendar. One codebase, four agent platforms, any language.

Rust-core incremental indexing engine: declare Target = F(Source) in Python and it keeps vector/graph/relational targets fresh forever, reprocessing only the delta — with per-row lineage.

HumanSignal's autonomous data-labeling agent framework: define a skill, give it ground truth, and the agent iterates — learn, apply, reflect — until it hits your accuracy threshold.

Email infrastructure for AI agents — send, receive, search and auto-extract verification codes via CLI/SDK, backed by a Cloudflare Worker; free hosted @mails.dev mailboxes or self-host.

A multi-agent software factory: describe a task, agents plan (PROMPT.md), build, review and merge in isolated worktrees — kanban + graph board, missions, agent chat rooms, any model. Early preview.

npx cc-lens: local analytics dashboard over ~/.claude — sessions with replay, cost and cache breakdowns, insights and budgets, team-adoption mode, a yearly Wrapped card. No cloud, no telemetry.

Layer-by-layer inference that runs 70B models on a 4GB GPU — no quantization required; 405B on 8GB, DeepSeek-V3 671B on ~12GB. One AutoModel line for most open model families.

120 marketing skills + 8 commands for Claude Code across 7 disciplines — SEO/GEO, influencer, paid ads, email, launch, social, brand — on one contract with 8 benchmark-driven auditor gates.

Plugin for Claude Code and 16 other hosts that turns any codebase into an interactive knowledge graph — multi-agent analysis, layered dashboard, guided tours, diff-impact view, domain mapping.

Giskard v3: modular Python evals and red-teaming for agentic systems — scenario-based checks with LLM-as-judge, plus an automatic vulnerability scanner across OWASP LLM Top-10 categories.

Paid-media operations skill for Claude Code across 12 ad platforms — source-grounded audits with deterministic scoring, versioned JSON reports, and account changes gated behind approval and rollback.

15 marketing skills for Claude Code — /market audit runs 5 parallel agents scoring a site across 6 dimensions; copy, email sequences, ad creative, competitor intel and client-ready PDF reports.

A disciplined 3-agent dev process as context files — Architect plans, Builder builds the brief, Reviewer gates — running in one Claude Code session via subagents. Token-frugal by design.

TIGER-AI-Lab's fully open deep-research recipe: 96K long-horizon trajectories (adopted by NVIDIA Nemotron), a 30B-A3B model hitting 54.8% BrowseComp-Plus, training code and eval harness.

OpenCode plugin giving coding agents persistent cross-session memory — local SQLite + vector search, automatic memory capture, user-profile learning, and a web UI. Nothing leaves your machine.

MCP server that puts MetaTrader 5 in an LLM's hands — natural-language trading, account and market data, order management over stdio/SSE, plus REST and WebSocket quotes. 32 tools, MIT.

Local-first dashboard over ~/.claude — sessions, timelines, per-session costs, tool/agent/skill/plugin analytics, live activity via hooks, and ticket linking. No cloud, no telemetry.

Live node-graph visualization of Claude Code and Codex sessions — watch agents think, branch into subagents and call tools in real time. VS Code extension or npx web app. Apache-2.0.

HKUDS multi-agent video studio: turns an idea, novel or screenplay into a finished film — scriptwriting, storyboards, consistent characters, then rendering via Seedance/Nano Banana/Omni APIs.

Self-hosted inference cluster for everything agents call besides the big LLM: embeddings, rerankers, OCR, NER, guardrails and small LLMs — 100+ models, one OpenAI-compatible API, K8s stack included.

Open causal engine for marketing simulation: a virtual consumer society with LLM personas answers do()-style counterfactuals — rank campaign combos, swap KOLs mid-flight, replay spend. Apache-2.0.

CMU framework that turns real software — browsers, IDEs, EMRs, CAD — into standardized agent environments: start the app, hand the agent a task, score it with automatic verifiers.

Local-first AI voice studio: clone voices, generate speech via 7 TTS engines in 23 languages, dictate system-wide with Whisper, and give any MCP-aware agent a cloned voice. Tauri, MLX/CUDA.

Provider-backed proxy that runs Claude Code, Codex or Pi on 25 cloud and local providers — fcc-* launchers, local Admin UI with validation, per-tier model routing, IDE/Discord/Telegram hookups.

THUDM recipe for deep-search agents: synthesize hard multi-hop QA from knowledge-graph random walks, then multi-turn GRPO RL — DeepDive-32B hits 14.8% BrowseComp; data feeds GLM-4.5/4.6.

Operator-based system for LLM data prep — 100+ operators composed into pipelines that generate, clean, evaluate and filter pretraining/SFT/RL data, with a WebUI and a pipeline-building agent.

Datalab's SOTA open OCR model: images/PDFs to structured HTML/Markdown/JSON with layout, tables, forms, checkboxes, handwriting and math, in 90+ languages. Local HF or vLLM inference.

Menu-bar/tray app for macOS and Windows that reads Claude Code, Codex and OpenCode session logs and shows live token spend — per-model pricing with cache reads, plan-limit bars, webhook alerts.

Self-hosted OSINT investigation platform — explore entities on a Neo4j-backed visual graph and expand them with 30+ enrichers: DNS/WHOIS/subdomains, breach checks, Maigret, crypto wallets.

Scale AI's open agent platform: scaffold agents with a CLI, run them behind the ACP protocol with a dev UI, and graduate from sync chat to durable Temporal-backed long-running workflows.

Self-hostable bookmark-everything app — links, notes, images, PDFs — with AI auto-tagging, OCR, full-text search, full-page archival, RSS auto-hoarding, and a CLI plus skills for LLM agents.

OpenAI-compatible proxy that stacks free tiers of 18 LLM providers (~1.7B tokens/mo) behind one /v1 — smart routing, failover, per-key quota tracking; Claude Code and Codex shims included.

Cross-harness 'operating system' for coding agents — 268 skills, 66 agents, hooks, rules, memory persistence, instinct-based continuous learning and AgentShield security scanning. MIT.

ZJU NLP's six-layer skill lifecycle platform: search a 500K+ index, author skills from traces/repos/docs/prompts, score quality on 5 dimensions, analyze skill graphs, orchestrate. SDK + CLI + MCP.

13 drop-in skills that fix prompt-caching bugs in OSS agent harnesses (Cline, Roo, Continue, OpenCode, Aider) — point your coding agent at the repo, it patches and verifies on the wire.

Self-improving context layer for data agents — ingests dbt/Looker/wikis, maps your warehouse, builds a semantic layer with approved metrics, and serves Claude Code/Codex via CLI and MCP.

Local-first CLI + web dashboard for your coding agents — switch providers, browse sessions across Codex/Claude Code/Gemini CLI, share skills, queue tasks, and bridge Codex/Claude to any API.

Community-maintained Chinese practice guide to OpenAI Codex — learning paths, CLI/App/Cloud/IDE setup, AGENTS.md templates, sandbox/approval safety and team playbooks, published at codexguide.ai.

Tauri/Rust desktop app that turns your Telegram account into unlimited cloud storage — file-explorer UI over channels, media streaming, share links, and a local REST API for LLM/tool integration.

Terminal-first orchestrator for issue-driven AI coding-agent runs — polls Linear/GitHub, runs Codex/OpenCode in git worktrees with retries and verification. Go/Charm rebuild of OpenAI's Symphony.

HKUDS' personal trading agent: one command gives your agent market data, analysis and trading capability, with a shadow-account mode, API and MCP surface.

Open-source, model-agnostic GitHub bot: tag @pullfrog on any issue or PR and your own coding agent (BYOK) runs the task inside GitHub Actions, context via an internal MCP server.

Hands-free voice conversation with any LLM behind a Live2D animated face — voice interruption included, running fully local and cross-platform.

Reverse-engineers any design system into a Claude-ready skill via pure static analysis — no AI, no API keys: point it at your codebase, get a skill that teaches your agent your UI.

A 7-layer memory operating system for Hermes Agent: Qdrant vectors, structured facts, fabric recall, an auto-curated wiki, and surgical context injection.

A document design system for AI agents: one constraint language and eight templates (plus a landing-page system) so agent-produced documents ship consistent instead of generic gray.

Knowledge-extraction CLI: LLMs turn documents into structured graphs, hypergraphs and spatio-temporal knowledge — with an MCP server for agents and Obsidian vault export.

Your own AI news radar: monitors the sources you choose and generates daily briefings in English and Chinese — self-hosted, personal, scheduled.

Agent skills for financial analysis and trading on the agentskills.io open standard — installable into Claude Code and friends, with a documented demo site.

18 mental models as Claude Code skills — First Principles, Bayesian reasoning, Systems Thinking, OODA, Pre-Mortem and more — invoked when a problem needs a thinking framework.

Karpathy's autoresearch loop as an installable skill for Claude Code, OpenCode and Codex: constraint + mechanical metric + autonomous modify→verify→keep/discard iteration.

Swarm-agent 'autonomous hedge fund': cooperating agents automate market analysis, risk management and trade execution. Python, from the Swarms ecosystem.

A fully autonomous 'AI company' on your own PC: 14 expert-modeled agents ideate, decide, code, deploy and market 24/7 — driven by Claude Code or Codex CLI, with a local dashboard.

A job-application framework built ON Claude Code: fork it, fill in your profile, and the agent evaluates postings, tailors CVs, writes cover letters and preps interviews — locally.

Open-source competitive-intelligence platform for agents: live Reddit/YouTube/TikTok/Maps/search connectors; scheduled agents produce briefs and alerts into a cited knowledge base. REST + MCP.

Document intelligence API in Rust: layout analysis, OCR with bounding boxes, and semantic chunking that turn PDFs, PPTs and Word docs into RAG-ready structured chunks.

The unified fine-tuning framework: 100+ LLMs and VLMs via LoRA/QLoRA/full-parameter, config-driven or through the LlamaBoard GUI. ACL 2024, 1000+ citations, 73k stars.

/council: 18 AI personas deliberate your hardest decisions across multiple LLM providers — structured multi-round disagreement, confidence-weighted verdicts, one slash command.

Visual workflow canvas that exports to the Markdown your agent already understands — design on nodes, ship as skills/agents/commands for Claude Code, Copilot, Codex, Gemini and more.

Open-source platform unifying AI agent orchestration with classic workflow automation — visual builder, 200+ integration components, self-hosted via Docker. Apache 2.0 + EE split.

Open-source AI security automation (SOAR): visual playbook builder, autonomous triage agents, and 80+ SIEM/EDR/identity/ticketing integrations. Self-hosted, multi-tenant.

One SQLite store under every Claude Code session: corrections become FTS5-searchable rules that auto-load, research grows persistent wikis, and 37 hook scripts add quality gates.

A methodology and toolkit for engineering AI skills instead of improvising them — plus a Context Skill Advisor that proactively recommends, improves or creates skills from what you're doing.

A director-skill for Claude Code/Codex: interrogates your vague video idea until it's a second-by-second storyboard spec (video-spec.md), ready for HyperFrames to render.

MindsDB's pivot: a unified 'Cowork' workspace where you delegate whole projects — apps, research, analysis, scheduled operations — to open-source models you can swap anytime.

A public library of reusable AI-agent loops plus Loopy, an installable skill that helps agents find, audit, adapt, run and publish loops from the live catalog.

Multi-agent terminal collaboration for AI CLIs: a manager, workers and an inspector — Claude Code, Gemini, Codex, OpenCode — coordinating through one-shot shell commands and SQLite. No daemon.

MCP server for undetectable browser automation: real Chrome via nodriver + CDP, Cloudflare/anti-bot bypass, AI-written network hooks — agents browse where Playwright gets blocked.

Alibaba's in-page GUI agent: one script tag gives any webpage its own AI agent — users drive the interface in natural language. TypeScript, tiny bundle, Chrome extension available.

Governance-as-code CLI for AI-assisted development: prompts and patches become RFCs, ADRs and work items with executable verification gates — reviewable, traceable, phase-gated delivery.

Open-source enterprise agent platform: RAG pipelines (upload or crawl docs), a visual workflow engine with MCP tool-use, and zero-code embedding into existing business systems.

Codebase intelligence for AI and humans: deterministic code-health scores calibrated on real defects, graph-aware refactoring plans agents can execute, auto-docs and git analytics over 9 MCP tools.

Open-source agentic browsing, twice: BrowserClaw — a browser your MCP agent drives using your real logged-in sessions — and BrowserOS, a Chromium fork with a built-in AI agent.

35 agentic patterns (Reflexion, LATS, GraphRAG, MemGPT, Voyager…) as one Python library plus a runnable textbook — real LLM outputs, 9 providers, benchmark leaderboard, 283 tests.

All-in-one agentic framework for video: understanding and summarization, clip editing, and generative remaking, driven end-to-end through natural-language conversation.

Alibaba's open-source in-process vector database: billion-scale similarity search embedded in your app, with DiskANN on-disk indexing, native full-text search and hybrid retrieval.

Runtime substrate that records agent runs as reversible, Git-like execution traces — meta-agents can observe, fork, replay and revert any run before outputs are applied or released.

Open-source red-teaming framework for LLM systems: 50+ vulnerabilities, jailbreak/injection/multi-turn attacks against agents, RAG pipelines and chatbots — plus guardrails. Runs locally.

One command installs your project's AI skill stack: scans package.json/Gradle/configs, detects the tech stack, and pulls matching skills from an audited, hash-verified registry.

Open-source framework for AI SRE agents plus the RL training and evaluation environment they need — connect 60+ tools you already run and investigate incidents on your own infra.

Curated skill marketplace for AI coding agents on the universal SKILL.md/AGENTS.md format — write a skill once, install it into Claude Code, Codex, Copilot, Cursor and friends.

Claude Code from any browser via your Tailscale tailnet — streaming chat UI, session history, model switching and cost dashboards; no SSH, no terminal.

Research framework that auto-distills agent trajectories into a three-level skill knowledge base (planning, functional, atomic) — pluggable into weaker agents and new environments.

The veteran Python web crawling framework: spiders, middlewares, pipelines and battle-tested scheduling — 60k+ stars and still the reference architecture for structured scraping.

Adaptive Python scraping framework: selectors that relearn when sites redesign, stealth fetchers that pass Cloudflare, spiders with proxy rotation and an MCP server — request to full crawl.

239 design skills, 88 commands and 33 plugins for Claude Code and Gemini CLI — research, design systems, UI, interaction and delivery, written for agents to actually execute.

Apify's web scraping and browser automation library for Node.js/TypeScript — HTTP and headless-browser crawlers with human-like anti-blocking defaults, queues, storage and proxies.

The standard library for letting AI agents drive a real browser — click, type, fill forms and complete tasks from a natural-language goal. 100k+ stars, Python.

Learn-by-example Python scraper: give it a URL and sample values you want, it infers the extraction rules and reapplies them to similar pages. Tiny, fast, zero selectors.

ByteDance's RL post-training library (HybridFlow): PPO/GRPO dataflows in a few lines, FSDP/Megatron training with vLLM/SGLang rollouts, production-proven at frontier scale.

Ultralytics YOLO (v8→26): real-time object detection, segmentation, classification, pose and tracking behind one Python/CLI API — train, validate and export to ONNX/TensorRT/CoreML.

Hugging Face's post-training library: SFT, DPO, GRPO, KTO and reward-model trainers on top of Transformers — from a Colab LoRA run to multi-GPU deployments.

Meta's Segment Anything 2: promptable zero-shot segmentation for images and video with streaming memory — click and box prompts become tracked masks in real time.

Low-code multi-agent framework: autonomous agents with built-in memory, RAG and MCP support across 100+ LLMs — from one agent to an 'AI workforce' in a few lines or YAML.

Open-source general autonomous agent from the MetaGPT team — the 'Manus without an invite code': browsing, tool use and multi-step task execution from a simple Python core.

NVIDIA's programmable guardrails for LLM apps: input, output, dialog and retrieval rails defined in Colang, wrapping any model or LangChain runnable.

H2O's no-code GUI and framework for fine-tuning LLMs — LoRA, 8-bit, DPO and experiment tracking behind a web UI, with CLI and Docker paths for the same configs.

NVIDIA's LLM vulnerability scanner: nmap-style probing for jailbreaks, prompt injection, data leakage, toxicity and hallucination across dozens of model endpoints.

Desktop cockpit for OpenCode: multi-instance sessions, git worktrees, remote browser access, voice input and a command palette — a workspace for living in AI coding sessions.

Lightweight Python face recognition and facial-attribute analysis (age, gender, emotion) wrapping VGG-Face, FaceNet, ArcFace and friends — pip install, self-hosted, battle-tested at 23k stars.

Unified virtual filesystem for AI agents — mounts S3, Slack, Gmail, Postgres and ~50 backends as one tree so any bash-speaking LLM can grep and pipe across services. Snapshotable, embeddable.

Open-source control plane that runs AI agents as microservices: write plain Python/Go/TS functions, get REST endpoints with routing, queues, retries, memory and tracing — one laptop to 10k agents.

Self-hosted gateway pointing any AI coding CLI (Claude Code, Codex, Cursor, Cline) at 40+ providers, with subscription→cheap→free auto-fallback and tool_result compression for 20-40% token savings.

Airgapped closed-corpus QA testbed: a local Qwen agent in a Pi harness explores a .zip dataroom with grep/embeddings/rerankers under a token budget — a bed to study search as test-time compute.

Reference repo plus npm CLIs (loop-init/audit/cost) for loop engineering: designing scheduled, gated control loops that prompt and orchestrate AI coding agents — Grok, Claude Code, Codex — over time.

Rust-core document-intelligence engine with 15 language bindings: turns 96 formats — PDF, Office, images, audio, code — into clean text, tables and RAG-ready chunks. Library, CLI, REST or MCP.

Heavyweight document-to-markdown/JSON parser — PDFs plus Office (docx/pptx/xlsx) through layout analysis and OCR into LLM-ready output for RAG and agentic pipelines. 73k stars, self-hostable.

Lightweight voice-cloning TTS — 48kHz speech at 150x realtime, fits in 1GB VRAM and runs on CPU or MPS. SOTA cloning from a ~3s reference sample, rivaling models 10x larger.

Autonomous bug-bounty agent for the terminal — recon, 20 vuln classes, a validation gate and submission-ready HackerOne/Bugcrowd reports. Runs as a Claude Code plugin or standalone on free providers.

Code-intelligence MCP server for coding agents — a pre-indexed semantic graph (libSQL + FTS5) they query instead of grepping: symbols, callers, impact radius in one call. 100% local, 50+ languages.

THUDM's RL post-training framework behind the GLM releases — Megatron training plus SGLang rollouts with native arg pass-through, and pluggable reward, verifier and agentic data-generation workflows.

Baidu's open OCR VLM that parses entire multi-page documents in one shot — 'unlimited' long-horizon parsing pushing DeepSeek-OCR further. MIT weights on HF; serve via transformers, vLLM or SGLang.

LangChain's batteries-included agent harness on LangGraph — planning, sub-agents with isolated context, filesystem, shell, skills, human-in-the-loop and persistent memory out of the box.

Distributed inference stack for Kubernetes from Red Hat, Google and IBM (CNCF) — prefix-cache-aware routing, tiered KV-cache, prefill/decode disaggregation and SLO autoscaling above vLLM/SGLang.

Long-term memory layer for AI agents — episodic (graph), profile (SQL) and working memory behind Python/TS SDKs, REST and MCP; ships LangChain, LangGraph, CrewAI and LlamaIndex integrations.

No-train, on-prem code knowledge graph served to AI agents over MCP — symbols, call edges, cross-language links and blast-radius queries, with a hash-chained audit log of every read.

Lakehouse graph database for agent context — graph, vector and full-text retrieval fused in one runtime on branchable Lance/S3 storage; agent fleets write on isolated branches and merge Git-style.

Microsoft's dependency manager for agent context — declare skills, prompts, plugins and MCP servers in apm.yml; one install reproduces the setup across 8 clients with lockfile pinning and org policy.

Scriptable skill manager for AI coding agents — install, search, dedupe-audit and security-scan skills across 19 providers, with --json/--yes on every command so agents and CI can drive it.

Package manager for AI agent skills — install from 400K+ skills across 31 sources, auto-translate between 46 agents' incompatible formats, security-scan on install, sync to every agent at once.

One markdown bootstrap file that scaffolds a structured workspace for any coding agent — persistent project docs plus a task tree run through a Think→Task→Execute→Verify cycle with human pacing gates.

Privacy-first meeting note-taker that runs 100% on-device: live Whisper/Parakeet transcription, speaker diarization, local Ollama summaries. Desktop app for macOS & Windows — no cloud, no call bots.

Self-hosted LLM gateway wrapping Claude Code, Cursor or Codex with zero code changes — strips unused tools, compresses JSON tool results ~88%, semantic-caches, tier-routes easy work to local models.

Self-hosted collaboration layer that turns local coding agents (Claude Code, Codex, OpenCode) into an always-on "AI company" — per-agent email, org chart, kanban, shared memory.

Claude Code plugin that learns from your corrections — hooks capture them in-session, /reflect syncs approved learnings to CLAUDE.md/AGENTS.md, /reflect-skills mines history into reusable commands.

Hardware-isolated microVM sandboxes for AI agents — sub-60ms boot, <5MB overhead, E2B-compatible API, self-hosted on your own KVM nodes.

The original "AI software company" multi-agent framework — role-assigned agents (PM, architect, engineer) turn a one-line requirement into PRD, design, and code.

Kyutai's 100M-parameter CPU-only TTS — streaming audio in ~200ms, ~6× real-time on two laptop cores, voice cloning, six languages. pip install and it talks.

Claude Code plugin that turns a feature spec into a reviewed PR through a 5-agent pipeline — PA → SWE → Tester → PR-Reviewer → On-Call — with exactly two human gates.

CLI + agent-skills layer that turns your coding assistant into a Google Cloud agent-lifecycle expert: scaffold ADK projects, run and evaluate them, then deploy and publish to Gemini Enterprise.

Self-hosted, always-on "personal AI OS": watches your apps, keeps a persistent memory graph, and acts autonomously within guardrails — a product, not a library for building agents.

Open toolkit that linearizes messy PDFs — scans, tables, equations, handwriting — into clean ordered Markdown with a self-hosted vision-language model. Built for LLM training data and RAG ingestion.

Open-source control plane for running fleets of heterogeneous AI agents as a "company" — bring your own agent, assign goals, org charts, budgets, governance, and an audited ticket system.

Multi-agent conversation framework for building LLM applications with cooperating agents.

Open-source embedding database for building AI apps with retrieval.

Orchestrate role-playing, autonomous AI agents that collaborate on tasks.

Program — don't prompt — your language models. Compile declarative pipelines into optimized prompts.

Build stateful, multi-actor LLM apps as graphs — durable execution, human-in-the-loop, streaming.

Trace, test and monitor LLM apps in production.

Data framework for connecting custom data sources to LLMs — ingestion, indexing, retrieval.

Run Llama, Mistral and other open models locally with a single command and a clean API.

Evaluation toolkit for your RAG and agent pipelines — faithfulness, relevance, and more.

High-throughput, memory-efficient inference and serving engine for LLMs.