Changelog

Rust headless browser for AI agents on Servo/Stylo components: fetch pages as Markdown or a semantic tree, automate via CDP, WebDriver or BiDi — about 13% of Chrome's memory per task.

Markdown to knowledge graph with an ontology you write: a small local decision model answers closed yes/no questions per candidate, and your cutoff keeps, queues for review or drops each link.

Datalab's 9B vision model that extracts JSON matching your schema from PDFs and images in one pass — schema-constrained decoding, multi-page values, vLLM or HF inference, Schema Studio.

Cache-to-Cache (ICLR'26): LLMs talk by projecting and fusing each other's KV-caches instead of generating text — higher accuracy than text relay at ~2x lower latency. Fuser weights on HF.

NVIDIA's security scanner for agent skills: 71 patterns across 17 categories — prompt injection, exfiltration, supply chain, MCP tool poisoning — static plus optional LLM pass, SARIF output.

Low-latency, multi-tenant property graph database that runs queries as sparse-matrix linear algebra (GraphBLAS); OpenCypher over the Redis protocol, built for GraphRAG and agent memory.

Strands Agents: open-source Python and TypeScript SDK for building and running agent harnesses in your process — model-agnostic, with lifecycle controls, hooks, MCP, multi-agent and tracing.

Strands' small decision model (2B, Qwen3.5-based): pick between options, answer yes/no or rate on a scale with calibrated confidence. CLI and /v1/systemone server on CUDA, MPS, MLX or CPU.

Project-based course on harness engineering for coding agents: 14 lectures, 8 projects on tools, state, verification and loops, plus breakdowns of Claude Code, Codex and Pi. 15 languages.

Apache Ossie (incubating, formerly Open Semantic Interchange): a vendor-neutral JSON/YAML spec for exchanging semantic models across BI, analytics and AI tools, with reference converters.

Rust agent harness built for fleets: desktop app, terminal or embeddable library, with built-in memory, browser/desktop control, 119 OAuth apps and 14 channels — 500 agents on a $10 VPS.

Microsoft's Go CLI for agent-skill quality: scaffold eval suites from SKILL.md, run them through Copilot, grade, compare models, replay snapshots and check spec and token budgets.

AG-UI, the Agent-User Interaction Protocol: ~16 standard event types that stream agent runs into frontends — chat, shared state, generative UI, frontend tools, human-in-the-loop.

Skill + local tool to review HTML and Markdown like a Google Doc: edit text, drag blocks, comment on elements, then send every change to your coding agent in one batch.

Intent compiler skill for coding agents: probes your repo, asks only what no file answers, halts on ambiguity, and emits a typed IntentSpec it later checks the delivered work against.

141k-star collection of 100+ runnable AI agent, agent-skill and RAG app templates — clone one, pip install, run — across Claude, Gemini, GPT and open models. Apache-2.0.

Google Research's Regularized Recursive Self-Improvement: evolves an agent harness (prompts, tools, memory, sub-agents) with constraints on the search so gains hold out of distribution.

Find code by asking what it does: `jg` uses the Jev decision model to judge folders, files and declarations, returning relevant files plus verbatim excerpts for coding agents. CLI + skill.

NVIDIA's safe runtime for autonomous agents: kernel-enforced sandboxes with policy on every file, syscall and connection; credentials injected only for approved endpoints.

Microsoft's text-space optimizer that trains a frozen agent's skill document like weights — rollouts, bounded edits, validation-gated updates — and ships a compact best_skill.md.

OpenBMB's RL training framework where every role — inference, training, rollout — is an independent service talking over one TransferQueue data plane. Built on SGLang and torchtitan.

vLLM's programmable decision layer: one endpoint for your agent harness that selects or combines models per call by policy — quality, latency, cost, location — across local and cloud backends.

Pick any model for any coding agent from one menu-bar app: a local gateway translating OpenAI, Anthropic and Gemini APIs, with subscription sign-ins and quota failover across accounts.

Self-hosted crew of AI agents on an org chart sharing one long-term memory: delegation, mid-task model switching, 1,000+ app connectors, reachable from terminal, WhatsApp, Telegram or Slack.

Block's self-hostable workspace where humans and agents share rooms on a Nostr relay — chat, canvases, workflows, patches and reviews as signed events; agents join with their own keys.

Self-learning skill layer for Claude Code: distills skills from your real sessions, merges same-scenario ones, updates them in use and prunes the unused — touching only skills it wrote.

Lossless long-term memory for a personal AI: verbatim JSONL logs, time-first search over SQLite FTS5 (sqlite-vec as last resort) and a tiny 'where are we now' index injected every turn.

Hooks Claude Code, Codex, OpenCode and Pi so every edit is checked against the rules in your AGENTS.md/CLAUDE.md by a decision model (Jev) — ~300 ms per check, violations fixed in-turn.

Office SDK for embedding spreadsheets, docs, slides, bases and PDFs in your own product — canvas rendering, formula engine, plugins and one Facade API across browser and Node.js.

Contrastive Language Models: CLM-8B, an open System-1 decision model scoring states against actions — typed choice/score/yes-no answers on a TypeSafe-compatible API, up to 9x faster than Jev.

Continual-learning byte-level LM trained from scratch on one 8 GB GPU: weights page in from disk, capacity grows and prunes itself while it keeps reading a single data stream.

Computer-use infrastructure for agents: sandboxed Linux, macOS and Windows desktops locally or in the cloud, Cua Driver for native apps (CLI/MCP/SDK), Lume VMs, CUA-S1 models, Cua Bench.

LlamaIndex's local document parser in Rust: PDFium text with bounding boxes at ~2-5 ms/page, selective Tesseract or HTTP OCR, Markdown/JSON output, screenshots; Python, Node, WASM.

Google's declarative runtime for agent workloads on Kubernetes: Task, Workspace and Model manifests run each agent sandboxed on Agent Substrate, with suspend/resume and ax ssh.

Nokia research: turn any open LLM into a Jev-style decision model. Typed choice, yes/no or score from one prefill, de-biased with no labels or a fitted head, served on vLLM.

Non-autoregressive decision engine: typed choice, score and yes/no answers over text in one forward pass (~33 ms), 100+ languages, calibrated probabilities, a router picking the checkpoint.

Kimi K3 (2.78T-parameter MoE) inference in portable C99 on one CPU: the dense trunk stays in RAM, 4-bit experts stream from disk, and output is byte-identical from 8 GB to 224 GB.

Serverless platform for agent sandboxes: stateful Firecracker microVMs with snapshots, cloning, auto suspend/resume and network policy, plus fan-out orchestration functions. Python SDK and CLI.

Memory and context engine for AI: fact extraction, user profiles, contradiction handling and forgetting, hybrid RAG + memory search, connectors, agent plugins and a one-binary local mode.

Renmin University's self-evolving ontology layer for data agents: builds a workload-grounded ontology over tables, files and databases, serves it via MCP, and evolves it from agent trajectories.

Rust RDF graph database and SPARQL 1.1 engine on RocksDB, with Python (pyoxigraph), JavaScript/WASM bindings and a CLI server, plus reusable crates for RDF parsing, serialization and SPARQL.

Coordination protocol for parallel coding agents above Git: agents declare intent in a shared SQLite store, and a deterministic detector flags plan collisions before code is written.

Local inference desktop app + CLI: profiles your hardware, estimates tok/s per model before download, tunes the one you pick, and connects Pi, OpenCode, Hermes, Codex or Claude Code in a click.

Markdown notes as a knowledge graph: an LSP for VS Code, Neovim, Zed and Helix, plus CLI and MCP so AI agents query the same files by structure. Rust, local-first, OKF-compatible.

Minimal TypeScript reference implementation of the Operational Ontology pattern behind Palantir Foundry: shared objects and links, action-gated writes, business rules, audit and write-back.

WhipCode: open-source coding agent in Go built on a recursive language-model loop; agents delegate to sub-agents through short programs, with daemon-owned sessions across desktop, TUI and web.

CNCF tool that syncs infrastructure assets and relationships (AWS, GCP, Azure, Kubernetes, GitHub, Okta and 30+ more) into a Neo4j graph, then runs security rules and Cypher queries over it.

Bend 2: a Python-like language with dependent types that compiles to fast CPU/GPU code; LAWS.bend declares invariants the compiler forces AI-written code to prove before it builds.

Embeddable semantic layer for AI agents: define metrics once, compose them with expressions and time shifts, row-level security and read-only SQL, over MCP, REST, CLI, Python or a Postgres facade.

Rust OLTP graph database on object storage with native vector and BM25 search: property graph, traversal-prefiltered ANN and full-text in one transactional engine; Rust, TS, Go, Python SDKs.

Cross-harness memory for coding agents: captures sessions from Claude Code, Cursor, Codex and 20+ harnesses, distills reviewed knowledge over MCP/skills, and forwards telemetry to SIEMs.

Desktop app implementing Karpathy's LLM Wiki pattern: an LLM ingests your documents into a persistent, interlinked wiki with a knowledge graph, hybrid search, deep research and an MCP server.

Microsoft's trigram-indexed grep: a client/server index narrows each regex to candidate files. Powers search in GitHub Copilot CLI; ships MCP tools and hooks for Codex and pi. Rust.

Mark Burgess's Semantic Spacetime knowledge graph on Postgres: write notes in the N4L language, compile them into a story graph, then search, browse and path-solve it via Go API or web UI.

Agent egress firewall in Go: an inline proxy scanning HTTP, MCP, A2A and WebSocket traffic for secret exfiltration, SSRF and prompt injection, with signed action receipts you verify offline.

Kubernetes SIG Apps' Sandbox CRD and controller: stateful singleton pods with stable identity and persistent storage for agent runtimes and RL — templates, claims, warm pools; gVisor/Kata isolation.

VS Code extension + CLI: author a labeled property graph schema as YAML on a canvas, then generate Neo4j, LadybugDB, Memgraph and FalkorDB schemas, SHACL, OWL, GQL, PG-Schema and LinkML.

NVIDIA's local inference router: pairs home machines running Ollama or LM Studio behind OpenAI-, Anthropic- and Ollama-compatible endpoints, sending each request to the best available node.

MemTensor's memory OS for LLM agents: one API over graph-structured, multi-modal memory with hybrid retrieval and skill evolution — hosted, self-hosted (Neo4j + Qdrant) or local plugins.

/graphify skill for Claude Code, Codex, Cursor and 20+ assistants: maps code, docs, PDFs and media into a local knowledge graph — tree-sitter AST, EXTRACTED/INFERRED edges, no vector store.

Code quality and coverage for coding agents: a Rust CLI that scores files with Jev, runs your existing test command, and turns uncovered paths into small actionable targets.

GitHub Next's local Jev bridge: a Bun/TypeScript POST /v1/systemone that translates typed decision questions into prompts for DiffusionGemma behind any OpenAI-compatible endpoint.

Browser Use's speed experiment: Jev picks the operation and the target element from an indexed action space in one request, and a small LLM writes text only when typing is needed.

One AI trade decision every Monad block: Jev reads the Kuru MON-USDC book every ~300ms, answers buy or sell, and the bot reposts a post-only limit order to earn the spread.

Claude Code plugin and npm library that replaces compaction summaries with Jev decisions: every tool call and result is scored, stale ones dropped or truncated, everything kept stays verbatim.

Open reproduction of TypeSafe's Jev: a LoRA + readout head on Qwen that answers many typed questions about one document in a single prefill pass, returning calibrated probabilities.

wt: the Rust git-worktree CLI built for parallel AI agents - worktrees addressed by branch name, `wt switch -c -x claude feat` creates one and starts an agent, plus hooks, list-with-status and merge.

NVIDIA's Pi extension with four auto-research-discovered efficiency mechanisms - action fusion, observation packing, evidence-preserving log reduction, online context compaction - all opt-in.

48k-star skill that stops coding agents burying the answer: lead with the next action, number steps, cap lists at 5, no preamble/recap/closers. ADHD-friendly, but it's for everyone.

Deep-research harness for Claude Code: a 16-step, tier-adaptive pipeline with adversarial critics, cite-checking and 250+ sources per run, every source kept in a persistent markdown+SQLite vault.

ZJU's self-hosted enterprise AgentOS on AgentScope 2.0: domain ontology as a control plane for agents, plus RAG, sub-agents, MCP, skills, sandbox, memory and approval-gated self-evolution.

Browser 'spy-satellite' simulator on real open data: live aircraft, ships, satellites, quakes and public cams on a photorealistic 3D globe, voice-driven by a realtime AI agent.

Capability-based WASM sandbox for MCP tools and agent-generated code: wasmtime + WASI with fuel, memory, time and I/O caps per run, sub-ms warm execution and signed (JCS/ES256) execution records.

Litho: a Rust, DeepWiki-style doc generator that turns any codebase into C4-model architecture docs - context, container, component and code-level pages with diagrams - via any LLM.

Group-chat orchestration for coding agents: Claude Code, Codex, ChatGPT Web and others in one durable group with an append-only ledger, read receipts, and Web/IM/mobile ops.

Tencent's team-level agent config manager: skills, rules, agents, hooks, MCP and env live in a shared git repo and sync into Claude Code, Codex, Cursor, CodeBuddy, OpenCode and more on every session.

Weave's Go model router: drop-in proxy speaking Anthropic, OpenAI and Gemini APIs that scores each request with an on-box ONNX embedder (Avengers-Pro clusters) and routes to the cheapest fit model.

Red Hat's 'ripgrep of AI context': a zero-dependency C++23 CLI + MCP that hands a coding agent a ranked call graph — what to touch, blast radius, tests to run — with no index server.

Continual-learning infra for self-improving agents: serve traffic (OpenAI/Anthropic-compatible), match feedback to runs, train weights via Slime/SGLang or evolve the harness, ship versioned updates.

Time travel for coding agents: a local proxy records any run (Claude Code, Codex, SDKs, even TLS-only harnesses), replays it byte-for-byte offline, and forks from any step onto a different model.

Git-native agent memory on Google's OKF v0.2: Markdown+YAML concepts in knowledge/, a zero-dep Go CLI/MCP with <300µs BM25 search, provenance and trust tiers.

Object-store-native distributed graph DB in Rust: graph on SlateDB over S3, snapshot-consistent OpenCypher, GraphBLAS traversal, Neo4j Bolt 5.x compatibility, disaggregated data nodes and indexers.

Self-hosted Apache-2.0 reference implementation of the Unified Harness Protocol: one OpenAI-Responses-style API running Codex, Claude Code, Hermes, Pi and DSH with sessions, streaming, files, traces.

Read-only inventory of every AI agent, MCP server, hook, plugin and AI extension on a machine: npx geiger-scan labels what can execute code, hold secrets or reach the filesystem, with evidence.

The 55k-star visual builder for LLM apps and agents — drag-and-drop chatflows and Agentflows, hundreds of nodes, self-hostable Node.js. Now ARCHIVED upstream (see 'Future of Flowise').

Local SQLite episodic memory shared across Antigravity, Claude Code, Cursor, Windsurf and Codex: hooks/MCP capture decisions, FTS5+model2vec hybrid recall reloads ~1k tokens per session.

Legible persistent agent memory: records observable execution events, consolidates only validated knowledge and explains every relation — MCP server on PostgreSQL 17 with a web explorer.

Office suite built for AI agents: one binary, no Office install, creates, reads and edits Word, Excel and PowerPoint, and renders them to HTML/PNG so the agent can see what it made. Ships as a skill.

Tencent WeChat's universal multimodal embedding family (2B/4B/9B): one vector space for text, images, video, visual documents and interleaved inputs, with Matryoshka dimensions from 64 to 4096.

Virtualized, elastic KV cache for LLM serving on shared GPUs: reserve virtual memory, back it with physical GPU memory only when used — vLLM and SGLang, with a memory-limit CLI, router and sleep mode.

Rust gateway that gives vLLM a stateful, OpenAI-compatible Responses API: server-side conversation state, server-side tool loops, SSE and WebSocket streaming, background runs — Codex-ready.

CopilotKit's self-hosted AI coworkers: each gets its own computer — a real browser with logins, files, granted tools — with every action decided before it runs and recorded after. Any AG-UI agent.

Browser ontology workbench for OWL and SKOS on Streamlit + rdflib: OWL-RL reasoning, 22 SKOS checks, SPARQL console, bulk edits, gist starters and a vis-network graph — no Java, no Protégé.

Molt: NVIDIA's agentic-first RL framework in ~9K lines — Ray for placement, vLLM for rollout, AutoModel + FSDP2 for training — fully async, multimodal, multi-turn, scaling to 1T-class MoE.

Open-source container and VM runtime for macOS in pure Rust: drop-in Docker engine, sub-100ms agent sandboxes (`abctl claude`), full Linux VMs and throwaway macOS guests on one daemon.

JIT-Agent: a meta-agent that writes a task-specific harness on the fly — memory, planning, action and capability modules emitted as code — and revises it from traces at test time.

zg: ripgrep, BM25 and vector search behind one local-first CLI for humans and agents — index a workspace once, search code, docs and data by meaning, then verify with exact text or regex.

Free MIT AI gateway for coding CLIs: one endpoint over 352 providers (150+ free tiers) and 1,200+ models with quota-aware auto-fallback, RTK+Caveman token compression, MCP/A2A and a desktop app.

DeepLethe's open 'enterprise world model': one Rust binary plus Postgres running a bitemporal knowledge graph with ontology packs, cited hybrid search, an agent harness and MCP. Air-gap ready.

Apache-incubating agent workspace where the append-only run log IS the runtime: desktop, TUI, CLI and Eval are thin clients of one host, and every harness benchmark ships with per-task records.

Notebook recipe that turns any text corpus into a concept graph with a local Mistral 7B via Ollama — chunk, extract concepts and relations, add proximity edges — for Graph RAG and KG QA.

System-level observability for AI agents via eBPF and TLS tracing: correlates prompts and model calls with the processes, files and network the agent actually touched — no SDK, no proxy.

btop-grade terminal dashboards in TypeScript: a one-import API over a typed-array framebuffer with differential rendering, Braille graphs and truecolor — zero runtime deps, Bun/Node/Deno.

Observability plus policy enforcement for agent harnesses: records every run across 12 harnesses (Claude Code, Codex, Cursor, Hermes…) and blocks dangerous tool calls with 39 built-in policies.

Agent skill for architecture, workflow, sequence, data-flow and lifecycle diagrams: the agent emits typed JSON IR, Archify compiles it deterministically to interactive HTML/SVG with PNG/WebM export.

YAML-defined ETL/ELT engine with a CLI and self-hosted control plane: Postgres/MySQL/Mongo/CSV/REST/PDF in, upserts with cursors, validation and quarantine, durable workers — AI transforms optional.

shadcn/ui registry of React components that faithfully recreate the Claude Code, Codex and Grok terminal UIs — headers, tool calls, diffs, prompts — built from real tmux captures.

UIUC's LLM routing library: 16+ trainable routers (KNN, MLP, matrix factorisation, Elo, graph, BERT) pick the best model per query, with xRouteBench and a train/serve CLI.

TypeScript library giving a backend one agent runtime: session-scoped runs with streaming, approvals and cancel, a tool registry, injectable stores and a factory over nine AI SDK providers.

Self-hosted digital human: a photo plus 10s of voice becomes a real-time talking head — Whisper to LLM to Chatterbox TTS to MuseTalk lip-sync, streamed over WebSocket, with barge-in.

Six dependency-free terminal apps for weather, sun, moon, tides, radar and maps, drawn from free public data with no accounts or API keys — mouse-friendly TUIs that try to match your terminal theme.

Receipt-to-JSON in one pip install: CLI, Python API and FastAPI service that send a receipt image to any OpenAI-compatible model and return merchant, totals and line items, plus a Tesseract module.

Native database IDE for Postgres, MySQL, SQLite, Redis, MongoDB, SQL Server and ClickHouse, with a built-in MCP server — 13 tools, 3-tier permissions, audit trail — and schema-aware AI chat.

PyTorch-shaped multi-agent framework: Session is the tensor, Agent the layer, Workflow the module — plus a v2 durable runtime with checkpoints, leases, an effect ledger and human interrupts.

Rust vector index with Python bindings built on Google's TurboQuant: no training step, online ingest, hand-written SIMD kernels — 10M x 1536 vectors in ~4 GB, with allowlist-filtered search.

NVIDIA's model-compression library: quantization (PTQ/QAT, FP8/NVFP4), pruning, distillation, NAS and speculative decoding over HF/PyTorch/ONNX, exported to TensorRT-LLM, vLLM and SGLang.

Claude Code skill that reads your local session logs and answers 'where did my tokens go' in plain English: deduplicated totals, cost charged to the tool that caused it, 5-hour window state.

Desktop agent IDE for fleets of coding agents: each task gets a worker with its own workspace and agent CLI, while a project orchestrator plans work and handles CI fixes, conflicts and reviews.

Desktop app plus MCP server keeping a codebase's ontology as reviewable Markdown in the repo: domains and capabilities linked to code evidence, compiled to a graph for blast-radius queries.

Self-hosted agent memory stack in Docker: Postgres + Qdrant + Neo4j hybrid retrieval, a temporal knowledge graph, ontology layer and freshness checks behind one MCP-native API.

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 ~11K 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 extraction orchestrator with 15 language bindings: 96 formats — PDF, Office, images, audio, code, web — to clean text, tables and RAG-ready chunks. OCR and structured extraction built in.

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.