Agents
Frameworks for building autonomous and multi-agent LLM systems.

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.

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.
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.

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.

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.

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.

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

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.
Multi-agent conversation framework for building LLM applications with cooperating agents.
Swarm-agent 'autonomous hedge fund': cooperating agents automate market analysis, risk management and trade execution. Python, from the Swarms ecosystem.
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.
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.

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.
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+.

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.
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-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.

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

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

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

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.
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.
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.

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.

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.
Your own AI news radar: monitors the sources you choose and generates daily briefings in English and Chinese — self-hosted, personal, scheduled.
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.
Build stateful, multi-actor LLM apps as graphs — durable execution, human-in-the-loop, streaming.
Data framework for connecting custom data sources to LLMs — ingestion, indexing, retrieval.
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.
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.
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.

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

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.
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.
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.

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.

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-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.
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.
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.
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.

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.
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.
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.

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.

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.

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.

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.
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.

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.

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.

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.
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.
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.

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.

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.

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.

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.
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.

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.
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.
HKUDS' personal trading agent: one command gives your agent market data, analysis and trading capability, with a shadow-account mode, API and MCP surface.

All-in-one agentic framework for video: understanding and summarization, clip editing, and generative remaking, driven end-to-end through natural-language conversation.
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.

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).