Stop building your AI stack from 40 open tabs.
A curated map of open-source AI & agent tools. Every connection is a typed, human-reviewed relationship — with the why written down. How we curate →
344 repos · 21 topics · curated by ShipWithAI · new: agentdock, ai-avatar-system, linecast →

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 ~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.
One email a week: what changed in the AI stack
New repos, new typed connections, the why behind each. No spam, unsubscribe anytime.