Open-Source Agents
Autonomous agents, browser control, sandboxes, orchestration frameworks, and MCP tooling.
Autonomous & Persistent Agents
Long-running agents with memory, goals, and self-direction.
OpenClaw
TypeScript · MIT · 🟡 active
Self-hosted personal AI assistant that runs on any OS and reaches you on any platform. One of the fastest-growing open-source projects ever.
- Replaces: ChatGPT desktop, Claude Desktop, Microsoft Copilot
- Backends: Any OpenAI-compatible API, Ollama, LocalAI
- Edge: Gateways into Telegram, Discord, Slack, WhatsApp, Signal, email, and CLI, so the agent reaches you where you already are — and can proactively message you. Large skill/plugin ecosystem. Security note: it holds credentials for your messaging accounts and runs autonomously; sandbox it and read the permission model before pointing it at anything sensitive.
Hivekeep
TypeScript · MIT · 🟡 active
Self-hosted platform to run a team of specialized AI agents that collaborate, keep persistent memory, and build their own tools, mini-apps, and plugins.
- Replaces: ChatGPT Team, Claude Desktop, hosted agent platforms
- Backends: Any OpenAI-compatible API, Ollama
- Edge: Multiple agents delegate to each other and share memory across months; a built-in web UI plus Telegram, Slack, Discord, and Matrix channels. Ships as a single container (Bun + SQLite), so the whole platform runs on modest hardware.
Hermes Agent
Python · MIT · 🟡 active
Nous Research’s self-improving agent — persistent memory, reusable skills, cron jobs, and 20+ messaging surfaces.
- Replaces: OpenAI Operator, Claude Desktop
- Edge: Closed learning loop: it creates skills from experience, refines them in use, and persists memory and session history in SQLite across restarts. Runs on a cheap VPS or serverless with no idle cost.
DeerFlow
Python · MIT · 🟡 active
ByteDance’s long-horizon “SuperAgent” harness — sandboxes, memory, skills, subagents, and a message gateway for tasks that run for minutes to hours.
- Edge: Built on LangGraph, but ships the whole runtime an agent actually needs (filesystem, memory, sandboxed execution, subagent spawning) instead of leaving you to assemble it. Hit #1 on GitHub Trending on the 2.0 release.
Open-Sable
Python · Local-first agent framework · 🟡 active
Autonomous agent with AGI-inspired cognitive subsystems — goals, working/episodic/long-term memory, metacognition, and tool use.
- Edge: Ollama-first with cloud fallback and a low-VRAM mode, so it genuinely runs on your own hardware. Memory decay and consolidation plus a watchdog/hot-reload supervisor make 24/7 operation realistic rather than aspirational.
AutoGPT
Python + TypeScript · MIT (classic agent) / Polyform Shield (platform) · 🟢 stable
The project that started the autonomous-agent wave, now a low-code platform for building and running continuous agents.
- Edge: Visual block-based builder plus a library of pre-built agents. Note the license split — the classic agent is MIT, the newer platform is source-available, not OSI.
Letta (formerly MemGPT)
Python · Apache-2.0 · 🟢 stable
Stateful agents with real long-term memory — the agent manages its own context window, paging memories in and out.
- Replaces: OpenAI Assistants API
- Edge: Memory is a first-class primitive backed by a database, not a vector-search bolt-on. Agents persist across sessions and are portable between models.
Mem0
Python + TypeScript · Apache-2.0 · 🟢 stable
Memory layer you drop into any agent — extracts, stores, and retrieves facts about users across sessions.
- Edge: Framework-agnostic. Hybrid vector + graph store beats naively stuffing the chat log into a vector DB.
kgai
Go · MIT · Claude Code plugin + CLI · 🟡 active
Local-first shared decision memory for engineering teams using Claude Code. An append-only log of architectural decisions and the alternatives that were rejected, projected into a knowledge graph the agent queries before it makes a change.
- Edge: The log is append-only and decisions are superseded, never edited or deleted, so a rejected approach stays in history with the reason it died. Teams sync the store over an S3 bucket they own, with no central server and no daemon. Capture rules live in a committed, per-repo config you approve before it runs.
Mnemoverse
TypeScript + Python · MIT (client) · 🟢 stable
Hosted memory reached over MCP: one key gives Claude Code, Cursor, VS Code and ChatGPT the same store, so what an agent learns in one is there in the next.
- Edge: Recall ranking moves with outcomes, not similarity alone. A memory that helped is promoted, one that misled is demoted, so ranking is a function of consequences.
Khoj
Python · AGPL-3.0 · 🟢 stable
Self-hosted personal AI that searches your notes, documents, and the web; reachable from browser, Obsidian, and Emacs.
- Replaces: ChatGPT with memory, Notion AI
- Edge: Indexes your corpus locally. Runs fully offline with local models.
Agent Sandboxes & Browser Control
Where agent-generated code actually runs, and how agents touch the web.
E2B
TypeScript + Go · Apache-2.0 · SDK + self-hostable infra · 🟢 stable
Secure cloud sandboxes for running AI-generated code, built on Firecracker microVMs.
- Replaces: proprietary code-interpreter backends
- Edge: microVM isolation gives each sandbox its own kernel — a genuine security boundary, not just a container namespace. That distinction matters the moment you execute code a model wrote. Python and JS SDKs, plus e2b-dev/infra if you need to run the whole platform yourself.
Daytona
Go + TypeScript · Apache-2.0 · Server + SDK · 🟠 experimental
Sandbox runtime for AI agents with fast warm-pool starts and filesystems that persist across sessions.
- Replaces: E2B (when you need persistence over isolation strength)
- Edge: sandboxes can pause, resume, and outlive a single session, which is what long-horizon agents actually need. Container-based rather than microVM, so treat the isolation as weaker than E2B’s — fine for your own code, think twice for genuinely untrusted input.
browser-use
Python · MIT · Library · 🟡 active
Connects an LLM to a real browser so it can navigate, fill forms, and extract data.
- Replaces: Stagehand, MultiOn
- Edge: the most widely used open browser agent, with multi-tab handling and vision fallback when the DOM isn’t enough. Known weakness: non-deterministic — the same goal takes different paths on different runs, which makes failures hard to reproduce, and vision calls on complex pages get expensive. Budget for retries and cap your spend.
Skyvern
Python · AGPL-3.0 · Library + server · 🟢 stable
Browser automation driven by computer vision instead of DOM selectors.
- Replaces: Stagehand, brittle Playwright scraping suites
- Edge: because it navigates visually, a site redesign doesn’t break your selectors — the usual reason scraping pipelines rot. Check the license: AGPL-3.0, and the anti-bot pieces are held back for the paid cloud. That combination rules it out for some commercial use.
Open Interpreter
Python · MIT · CLI + Desktop · 🟢 stable
Lets Language Models run code locally on your computer to edit videos, analyze data, and control browsers.
- Replaces: OpenAI Code Interpreter (Advanced Data Analysis)
- Backends: Local models (Ollama, LM Studio) or hosted APIs (OpenAI, Anthropic)
- Edge: Runs directly in your local terminal environment with full access to system utilities, internet, and python packages without cloud execution limits.
Superagent
TypeScript + Swift · MIT · Desktop app · 🟡 active
macOS desktop app that gives Claude Code and Codex a real browser to drive, an iOS Simulator to install and screenshot apps in, and a phone companion app for remote monitoring.
- Replaces: cloud sandbox services for agents that specifically need a real, controllable macOS browser/iOS Simulator rather than a headless container
- Backends: Claude Code, Codex
- Edge: unlike headless sandboxes, the browser and Simulator are visible and drivable on the user’s own Mac, so the agent can screenshot real rendered UI and iOS app behavior instead of a DOM approximation.
Agent Frameworks & Orchestration
Libraries for building multi-agent and tool-using systems.
LangGraph
Python + JS · MIT · 🟢 stable
Build agents as stateful graphs — nodes, edges, and explicit control flow, with checkpointing and human-in-the-loop interrupts.
- Edge: Durable execution: an agent can pause for hours awaiting human approval and resume with full state. The right choice when you need a reliable agent, not a demo.
CrewAI
Python · MIT · 🟢 stable
Role-playing autonomous agents that collaborate — a “crew” with defined roles, goals, and tasks.
- Replaces: AutoGen, OpenAI Swarm
- Edge: Independent of LangChain, lean runtime. The role/task abstraction is the most intuitive on-ramp to multi-agent design. Flows give you event-driven control when crews are too loose.
AutoGen
Python + .NET · MIT · 🟢 stable
Microsoft’s framework for multi-agent conversation — agents talk to each other, execute code, and involve humans.
- Edge: Async event-driven core with a distributed runtime and cross-language support. AutoGen Studio gives a no-code prototyping UI.
smolagents
Python · Apache-2.0 · 🟢 stable
Hugging Face’s minimal agent library — the core logic is about a thousand lines.
- Edge: The fastest path to a working single-agent loop. Code agents write Python actions instead of emitting JSON tool calls, which is measurably more reliable for multi-step tasks. Read it end-to-end in an afternoon.
Google ADK
Python + Java · Apache-2.0 · 🟢 stable
Code-first toolkit for building, evaluating, and deploying multi-agent systems.
- Edge: Model-agnostic and deployment-agnostic despite the Google name. Built-in evaluation and a local dev UI close the “how do I know my agent got worse?” gap that most frameworks ignore.
Pydantic AI
Python · MIT · 🟢 stable
Agent framework from the Pydantic team — type-safe, structured outputs, dependency injection.
- Edge: If you already trust Pydantic for validation, this brings the same rigor to LLM I/O. Feels like FastAPI for agents.
DSPy
Python · MIT · 🟢 stable
Program LLMs instead of prompting them — declare modules and let optimizers compile the prompts.
- Edge: Replaces manual prompt-tweaking with systematic optimization against a metric. Swap the model, recompile, keep the quality.
LiteLLM
Python · MIT · 🟢 stable
One OpenAI-compatible interface for 100+ LLM providers, plus a proxy with keys, budgets, rate limits, and fallbacks.
- Replaces: OpenRouter (hosted)
- Edge: The single most useful piece of plumbing in the stack. Provider outage → automatic fallback. Per-team budgets and spend tracking come free.
Haystack
Python · Apache-2.0 · 🟢 stable
Production-oriented framework for composable RAG and agent pipelines.
- Edge: Explicit, inspectable pipeline graphs. Strong retriever/ranker ecosystem — favored when search quality is the hard part.
Model Context Protocol (MCP)
The emerging standard for connecting models to tools and data.
MCP Specification
MIT · 🟢 stable
The protocol itself — open standard for exposing tools, resources, and prompts to any LLM client.
- Edge: Write an integration once; every MCP-capable client (Claude Code, OpenCode, Cline, Continue, and more) can use it.
MCP Servers
MIT · 🟡 active
Reference implementations — filesystem, git, fetch, memory, and dozens of community servers.
- Edge: The fastest way to learn the protocol is to read a 200-line server that already works.
Mac Developer Bridge
JavaScript · MIT · macOS / MCP · 🟠 experimental
Local MCP bridge that lets an existing ChatGPT conversation operate the Mac where the developer is already working: shell, unrestricted files, real PTY sessions, background jobs, and read-only Codex history.
- Edge: ChatGPT stays the reasoning layer and the bridge makes no model calls. Unlike a narrow filesystem or shell MCP, it is deliberately built for developer-machine parity and real interactive terminals. Security tradeoff: it is intentionally not sandboxed and runs with the macOS user’s effective permissions, so it is only appropriate when that level of machine access is explicitly wanted.
MCP Inspector
TypeScript · MIT · 🟡 active
Official developer tool for testing and debugging MCP servers.
- Edge: shows you the actual protocol traffic — tool calls, resources, errors — instead of leaving you guessing why a client won’t load your server. First thing to reach for when an MCP integration silently does nothing.
FastMCP
Python · Apache-2.0 · 🟡 active
The ergonomic way to build MCP servers and clients — decorator-based, like FastAPI.
- Edge: A working server in ~10 lines. Handles auth, deployment, proxying, and server composition.
octocode
Rust · Apache-2.0 · 🟠 experimental
Local semantic code index with an MCP server on top — search and navigate a codebase by meaning, not grep.
- Replaces: the codebase indexing inside Cursor or Sourcegraph Cody
- Backends: local embeddings via fastembed, or a hosted provider if you’d rather offload it
- Edge: runs entirely locally, and embeddings are your choice. Known weakness: first index on a large repo is slow, and semantic search is genuinely bad at structural questions — “find every implementation of this trait” wants a structural index, not embeddings, so you need separate structural tools and have to know which kind of question you’re asking before you search. Early-stage; treat it accordingly.
