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

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

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.

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

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

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

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

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

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

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.

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

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

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

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.

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

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

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.

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

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.

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

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.

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