Awesome Open AI Developer Tools
Awesome Open AI Developer Tools
A curated guide to the open-source AI stack — every layer, every proprietary tool you can replace.
Coding agents · local inference · agent frameworks · vector DBs · RAG · evals · observability
English · Türkçe · 简体中文 · Español · add your language · 🌐 Website
Every entry answers three questions:
- What does it do?
- What closed-source product does it replace?
- Why would you pick it over the alternatives?
Each entry also carries a maturity badge: 🟢 stable (production-ready) · 🟡 active (works great, moves fast) · 🟠 experimental (early, expect rough edges).
No affiliate links. No sponsored slots. OSI-licensed only — source-available tools are included but labeled.
On licenses: the license shown for an entry is a pointer, not a guarantee — projects relicense, and this list lags. Read the
LICENSEfile in the repository before depending on one commercially. Where no license is shown, we have not confirmed it.
Contents
- Coding Agents & Pair Programmers
- Prompt-to-App Builders
- Autonomous & Persistent Agents
- Agent Sandboxes & Browser Control
- Agent Frameworks & Orchestration
- Agent Skills & Package Management
- Model Context Protocol (MCP)
- Local Inference Engines
- Inference Servers & Gateways
- Chat UIs & Frontends
- Vector Databases
- Embeddings & Rerankers
- RAG Frameworks
- Fine-Tuning & Training
- Evals, Testing & Guardrails
- Observability & LLMOps
- Speech, Vision & Multimodal
- Low-Code / Visual Builders
- Open-Source Alternatives Cheat Sheet
- Choosing Your Stack
- Contributing
Coding Agents & Pair Programmers
Agents that read, write, and refactor code in your repo.
aider
Python · Apache-2.0 · CLI · 🟡 active
AI pair programming in your terminal. Maps your whole repository, edits files directly, and writes its own git commits.
- Replaces: GitHub Copilot, Cursor
- Backends: 100+ models via LiteLLM — Claude, GPT, Gemini, plus local models through Ollama or any OpenAI-compatible endpoint
- Edge: The repo map gives it whole-codebase context without dumping every file into the prompt. Auto-commits mean every AI edit is a revertable checkpoint. Editor-agnostic — works alongside VS Code, Neovim, Emacs, or nothing at all.
OpenCode
TypeScript · MIT · TUI · 🟢 stable
Terminal-native coding agent with LSP integration — it loads the right language server so the model sees real type information, not guesses.
- Replaces: Claude Code, Cursor
- Backends: Anthropic, OpenAI, Google, local models; provider-agnostic by design
- Edge: LSP-grounded suggestions cut hallucinated APIs. Client/server split means you can drive one session from multiple clients.
Cline
TypeScript · Apache-2.0 · VS Code extension · 🟢 stable
Autonomous coding agent inside VS Code. Plans, edits files, runs terminal commands, and uses the browser — asking permission at each step.
- Replaces: Cursor Composer, Devin
- Backends: Anthropic, OpenAI, Google, AWS Bedrock, Azure, OpenRouter, Ollama, LM Studio
- Edge: Human-in-the-loop by default — every file diff and shell command needs approval. Plan/Act mode separation stops the agent from bulldozing a codebase.
Continue
TypeScript · Apache-2.0 · VS Code + JetBrains · 🟢 stable
Build your own AI code assistant — autocomplete, chat, and edit, configured with your own models and context providers.
- Replaces: GitHub Copilot
- Backends: Any — local (Ollama, llama.cpp) or hosted
- Edge: Fully configurable context providers (docs, terminal, git diff, codebase). Tab-autocomplete works well with small local models, so you can run genuinely offline.
OpenHands
Python · MIT · Web + headless · 🟢 stable
Agents that do what a developer does — modify code, run commands, browse the web, call APIs — inside a sandboxed runtime.
- Replaces: Devin
- Backends: Anything LiteLLM supports
- Edge: Real sandboxed execution (Docker) rather than a chat that pretends to run things. Headless and CLI modes make it scriptable in CI.
PatchPilot
Python · MIT · Local web UI · 🟠 experimental
Local-first coding agent that plans changes, applies guarded edits, runs approved tests in disposable Docker containers, and produces reviewable Git diffs.
- Replaces: Hosted coding-agent experiments for basic local edit-and-review workflows; not a feature-for-feature replacement for mature agents
- Backends: Local Ollama, OpenAI-compatible endpoints, OpenRouter
- Edge: Test execution fails closed without an approved offline Docker image instead of running project scripts on the host. It also bounds Git output, checks staged changes for recognizable secrets, and documents the remaining host-side isolation risks.
SWE-agent
Python · MIT · CLI · 🟡 active
Research-grade agent that turns a GitHub issue into a pull request.
- Replaces: Devin, issue-to-PR bots
- Edge: The agent-computer interface (ACI) is the point — carefully designed tools beat a bigger model. If you’re building your own agent, read this codebase first.
Goose
Rust · Apache-2.0 · CLI + desktop · 🟢 stable
Extensible autonomous agent from Block, now governed by the Linux Foundation. Installs, executes, edits, and tests — not just suggests.
- Replaces: Devin, Cursor agent mode
- Backends: Any provider, plus first-class MCP extension support
- Edge: More autonomous than aider — plans and iterates with less hand-holding. Vendor-neutral governance under the Linux Foundation means no rug-pull risk, which matters for tooling you standardize a team on.
molt
TypeScript · Apache-2.0 · CLI + desktop · 🟡 active
Coding agent that won’t say done on a false claim — verification on disk, receipts for accepts and refusals.
- Replaces: Cursor agent mode, Claude Code for teams that need a done-bar outside the model
- Backends: OpenAI-compatible endpoints (Ollama, vLLM, etc.) or Anthropic
- Edge: Acceptance lives in
.molt/done.ymlagainst real files; accepts and refusals both write hash-chained receipts (molt verify). Install from the GitHub releases or build from source.
BitFun
Rust + TypeScript · MIT · Desktop + CLI · 🟡 active
Cross-platform coding and desktop agent that plans, edits, tests, and commits inside real Git repositories.
- Replaces: Cursor, Claude Desktop
- Backends: User-configured model providers; model-agnostic by design
- Edge: A Rust runtime binds each conversation to task-specific Mini Apps while retaining filesystem, terminal, Git, browser, desktop, and remote-workspace execution. A self-hostable zero-knowledge relay supports cross-device session control without routing workspace data through a vendor cloud.
Orkas
TypeScript · MIT · Desktop · 🟡 active
Local-first desktop AI workforce where a Commander plans work and coordinates built-in specialists and external coding agents through one chat.
- Replaces: Cursor agent mode, cloud-hosted agent orchestrators
- Backends: Claude, OpenAI, Gemini, DeepSeek, Kimi, GLM, Qwen, MiniMax, Doubao, and compatible local model endpoints
- Edge: Orkas runs the orchestration layer on the user’s machine: conversations, files, agent configuration, and model keys stay local, while the Commander can dispatch Claude Code, Codex, OpenCode, OpenClaw, and Hermes as local subprocesses alongside built-in agents.
MulmoTerminal
TypeScript · MIT · Browser / CLI · 🟢 active
Browser grid of live Claude Code and Codex sessions, one real PTY per cell, started with a single npx command. Each cell is colour-coded working / needs-you / done, so a session blocked on a permission prompt is distinguishable from one still thinking without opening it.
- Replaces: tmux panes plus a notifier script, hand-rolled session dashboards
- Backends: the
claudeandcodexCLIs you already installed and pay for; Grok and Antigravity also supported - Edge: session state comes from the agent CLI’s own hooks (
PreToolUse/Stop/Notification), not from parsing scrollback, so “working” and “waiting on you” are different states rather than both being “output stopped”. tmux backs the sessions, so they survive a server restart or a reboot; each cell can hold its own git worktree with commit, push and PR from the grid.
ordewell
Rust · Apache-2.0 · CLI / TUI · 🟡 active
Plan-first CLI/TUI orchestrator that converts a single goal into an ordered, editable plan of coding-agent tasks.
- Replaces: Manual task decomposition and multi-agent CLI scripting
- Backends: Claude Code, Codex, OpenCode
- Edge: Features a read-only planner that generates explicit step-by-step agent plans before execution, with per-task runner, model, and mode assignment.
LoopTroop
TypeScript · MIT · Desktop + CLI · 🟡 active
Local orchestrator that turns complex coding tickets into verified pull requests using multi-model planning councils and isolated git worktrees.
- Replaces: Devin, Cursor agent mode, cloud-hosted agent orchestrators
- Backends: Anthropic, OpenAI, Google Gemini, DeepSeek, OpenRouter, and local models via OpenCode
- Edge: LoopTroop runs an LLM council where distinct models draft and vote on task plans before implementation starts. Each task executes inside an isolated git worktree with bounded retry loops, so failed runs roll back without touching the primary checkout. Human approval gates pause execution before irreversible terminal commands or branch updates run.
Atomic Agent
TypeScript · MIT · CLI + TUI · 🟠 experimental
Local-first coding and desktop agent that runs open-weight models on your machine, with no account or API key needed to install and run it.
- Replaces: Claude Code, Cursor, GitHub Copilot
- Backends: Bundled
llama.cppfork for local quantized models, plus any OpenAI-compatible endpoint, with presets for OpenRouter, LM Studio, and Ollama Cloud - Edge: Ships its own
llama.cppfork and manages the backend process itself, so a quantized local model stays usable across long multi-step runs without a separate server setup. The control loop and all state, including a five-layer memory store, stay on the machine, and 56 built-in tools cover browser, filesystem, git, and vision alongside external MCP servers. The README labels it a developer preview: APIs, commands, and config still move between releases.
Kilo Code
TypeScript · Apache-2.0 · VS Code + JetBrains · 🟢 stable
Open-source IDE agent that merged the best of Roo Code and Cline into one extension.
- Replaces: Cursor, Windsurf
- Edge: Orchestrator mode splits a large task into subtasks handled by specialized modes. Absorbs upstream features from both parents, so it moves faster than either did alone.
Tabby
Rust · Apache-2.0 · Self-hosted server · 🟢 stable
Self-hosted AI coding assistant with its own inference server, no external API calls.
- Replaces: GitHub Copilot (enterprise)
- Edge: Runs on consumer GPUs, OpenAPI interface, and answers the compliance question (“where does our code go?”) with “nowhere.”
gpt-engineer
Python · MIT · CLI · 🟠 experimental
Describe a project in natural language; it writes and iterates on the whole codebase.
- Edge: Best for greenfield scaffolding rather than surgical edits on an existing repo.
Orbi
Python · AGPL-3.0 · Self-hosted runner + GitHub · 🟢 stable
Works from GitHub issues: label one ai-ready and it implements the change in an isolated worktree, opens a PR, and a separate review session checks the diff against the issue’s acceptance criteria before anything merges.
- Replaces: Devin, GitHub Copilot coding agent
- Backends: Any OpenAI-compatible model, or a Codex subscription
- Edge: Review is a gate, not a suggestion: only the exact head the reviewer approved is merged, and Orbi then cuts the tagged release. Ops tickets (deploys, investigations) post their real commands and output on the issue.
Ivy Tendril
TypeScript · MIT · Desktop + Web · 🟡 active
Agentic software factory that manages parallel Git worktrees with programmatic verifications and interactive review loops.
- Replaces: Manual git worktree management, multi-agent branch orchestration
- Backends: Anthropic, OpenAI, local models
- Edge: Automates parallel Git worktree isolation with built-in programmatic verification gates and interactive human-in-the-loop review loops before merging.
md²
TypeScript + JavaScript · AGPL-3.0 · Desktop app · 🟡 active
Local desktop workspace that organizes Codex and Claude Code work around Markdown feature cards and isolated Git worktrees.
- Replaces: Conductor, manual task-board and terminal/worktree orchestration
- Backends: Codex CLI and Claude Code CLI, with multiple accounts and agent switching
- Edge: Keeps feature definitions as local, versionable Markdown while connecting each card to its agent conversations, worktree, commits, diagrams, and merge workflow. Built-in statistics provide insight into agent usage, performance, and cost. Turn code into editable diagrams and diagram changes back into code.
YYLO
Python + TypeScript · MIT · CLI · 🟡 active
Command-line orchestrator for coding agents, repeatable workflows, and receipt-backed repository changes.
- Replaces: Manual multi-agent workflow scripting, cloud-hosted agent orchestration
- Backends: Drives Pi and Codex subagents through per-subagent aliases
- Edge:
task startfreezes the protected target SHA and creates a dedicated branch/worktree per task; a merge queue then owns risk-based review — low risk merges with no semantic reviewer,
CodeOtter
JavaScript + TypeScript · AGPL-3.0 · Self-hosted server + CLI · 🟡 active
Self-hosted AI pull request reviewer for GitHub, Forgejo and Gitea that scores each PR, enforces merge gates as status checks and posts committable inline fixes.
- Replaces: CodeRabbit, GitHub Copilot code review
- Backends: Local GGUF models via a managed llama.cpp runtime, Anthropic, OpenAI, OpenRouter, MiniMax
- Edge: Scores and pass/fail gates can come from a separate typed-answer model rather than parsed prose, so merge gates don’t depend on LLM formatting. Runs fully offline, reads the repo’s
AGENTS.md/CLAUDE.md, and works with self-hosted Forgejo and Gitea, not only GitHub.
workkit
JavaScript + Shell · FSL-1.1-MIT (source-available, not OSI) · Claude Code plugin + CLI · 🟡 active
Claude Code plugin that runs GitHub Issues as the work pipeline: each issue moves through labeled stages from spec to build, QA and ship.
- Replaces: Ad-hoc chat-driven coding sessions and hand-kept task lists
- Backends: Claude Code (Anthropic)
- Edge: The chat acts as a manager that dispatches worker subagents for code and tests plus a verifier that reviews both without seeing how they were made. Hooks block a code commit until the full test suite has passed on exactly what is being committed, and finished work waits uncommitted for the human to try it.
Sqwakie
TypeScript · FSL-1.1-ALv2 (source-available, not OSI; converts to Apache-2.0) · Background daemon + CLI + MCP + web dashboard · 🟠 experimental
Puts a small team’s people and their Claude Code and Codex agents on one team: agents message and ask each other peer to peer, and one dashboard shows what every agent across everyone’s machines is doing.
- Replaces: Relaying questions between teammates’ agents through Slack, email or copy-paste
- Backends: Claude Code, Codex
- Edge: Agents call
post,get,reply,subscribeandaskfrom the CLI or as MCP tools, so one agent’s question reaches a teammate’s agent directly. Daemons connect peer to peer (QUIC with NAT hole-punching, built on iroh) and replicate a signed, append-only team log; when there is no direct path, a relay forwards encrypted traffic it can’t read. Project kanban cards can be started, reviewed and finished by agents.
Volt
TypeScript · MIT · Desktop IDE (VS Code core) · 🟠 experimental
Open-source agentic workspace on the VS Code core that puts agent chats, code, Git, a browser and a terminal in one window.
- Replaces: Cursor
- Backends: Claude Code and Codex agent CLIs over the Agent Client Protocol (ACP), plus local models through Ollama and tools through MCP
- Edge: Agent edits land as hunk-level diffs you keep or revert, with Git checkpoints and worktrees so parallel agents don’t collide. Because it runs on the real VS Code core, existing extensions, themes, keybindings and debuggers keep working.
Sno Station
TypeScript · Apache-2.0 · CLI + skills added to the agents you already run (no daemon) · 🟡 active
Turns Codex, Claude Code, Cursor, Hermes Agent and OpenClaw into one squad on your own computer: they share one memory, hand work to each other, and review each other’s work when you ask.
- Replaces: Pasting context between two agent sessions when one hits its usage limit; asking an agent to review its own work
- Backends: Codex, Claude Code, Cursor, Hermes Agent, OpenClaw
- Edge: When one agent hits a rate limit mid-task, another agent picks the task up from the same memory, so nothing is pasted. A review request always goes to a different agent than the author, so the reviewer has no habit of agreeing with it. A nightly pass consolidates memory across all sessions and proposes edits to the agents’ own skills, which you approve or reject in the morning.
DevIntern
TypeScript · FSL-1.1-ALv2 (source-available) · CLI daemon (self-hosted worker) · 🟢 stable
One self-hosted worker that routes tracker tickets across many repositories and turns them into pull requests with the coding agent you already have.
- Replaces: Devin, GitHub Copilot coding agent, Factory
- Backends: Claude Code, Codex, Cursor, OpenCode
- Edge: Routing rules in one
workspace.tomlsend Jira, Linear or GitHub Issues tickets to the right repo, each run in a disposable git worktree. An optional auto-review step has the agent critique and fix its own diff before the PR opens. The same daemon runs cron-scheduled prompts and Sentry-to-PR fixes, and turns review comments, failing CI and merge conflicts into follow-up commits without force-pushing.
Prompt-to-App Builders
Prompt in, deployed full-stack app out.
bolt.diy
TypeScript · MIT · 🟢 stable
Official open-source fork of Bolt.new. Prompt, run, edit, and deploy full-stack web apps in the browser — with the LLM of your choice.
- Replaces: Bolt.new, v0, Replit Agent
- Backends: OpenAI, Anthropic, Google, Groq, Mistral, DeepSeek, xAI, Ollama, LM Studio, OpenRouter, any OpenAI-compatible endpoint
- Edge: Self-hostable with zero telemetry. Multi-provider switching mid-project means you can start on a cheap model and escalate only where it matters.
Open Design
TypeScript · Apache-2.0 · Desktop + web · 🟠 experimental
Turns the coding agent you already have into a design engine — prototypes, landing pages, dashboards, slides, images, and video, exported as HTML/PDF/PPTX/MP4.
- Replaces: Claude Design, Figma Make
- Backends: BYOK through whatever agent is on your PATH — Claude Code, Codex, Cursor, Gemini, OpenCode, Qwen, and 20+ others
- Edge: Ships with a large library of brand-grade design-system packages, and every render reads a
DESIGN.mdbrand contract, so output is consistent instead of randomly styled. Local-first: your brand assets never leave the machine.
OpenUI
Python + TypeScript · Apache-2.0 · 🟡 active
Describe a UI, watch it render live, convert it to React/Svelte/Vue.
- Replaces: v0.dev
- Edge: Live iteration loop — describe the change, see it immediately. Works with local models via Ollama.
Dyad
TypeScript · Apache-2.0 · Desktop · 🟢 stable
Local, open-source AI app builder. Runs on your machine, bring your own API keys.
- Replaces: Lovable, v0, Bolt
- Edge: No vendor lock-in and no cloud round-trip for your source code.
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.
Tale
TypeScript · MIT · Web app · 🟡 active
Self-hostable project workspace for people and AI agents to delegate tasks and review reports and delivered files together.
- Replaces: Hosted agent workspaces for team task delegation and review
- Backends: Supported coding runtimes including Claude Code, Codex, and OpenCode, with separately configured compatible provider credentials
- Edge: Each project agent reuses a persistent sandbox workspace across tasks, while task attachments and collected deliverables stay attached to the work. Task context and acceptance criteria guide execution, and completed work goes to a designated reviewer.
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.
5dive
Shell · MIT · Self-hosted / CLI · 🟡 active
Runs a team of AI agents on a server you own; you message them like coworkers on Telegram or Discord.
- Replaces: Devin, Lindy
- Backends: Claude Code, Codex and other official agent CLIs with your own subscription or API key, any model through OpenRouter, or a local server (vLLM, llama.cpp, an Ollama shim)
- Edge: No framework or broker: the orchestrator is bash, and each agent is a Linux user running a systemd service with SQLite for state and journald for logs, so a single-agent setup fits on a 1 GB VM. Agents hand each other work through an org chart and a shared backlog.
aiFetchly
TypeScript · Apache-2.0 · Desktop app · 🟡 active
Open-source desktop AI agent for business automation — lead generation, knowledge library RAG, outreach, and scheduled workflows. Runs on Windows, macOS, Linux.
- Replaces: Cloud-hosted business automation and lead-generation agents
- Edge: Local-first: SQLite + sqlite-vec storage, permission-gated tools, skills/plugins/MCP servers. Cron scheduling, subagents, Puppeteer browser automation for lead-gen/outreach loops.
kwant
Rust · AGPL-3.0 · Self-hosted binary, Mac app, Linux .deb/AppImage · 🟡 active
Self-hosted team of AI bots in one binary that share chats, hand work to each other with an @mention, and run routines on a schedule.
- Replaces: Hosted agent teams such as Grok Bot, Claude Duet and OpenAI dots
- Backends: Claude, Codex and Grok CLI logins; Anthropic, OpenAI and xAI keys; any OpenAI- or Anthropic-compatible server, including local models
- Edge: Spaces keep separate bots, accounts, routines and approval rules for work and home, and when one account runs out of usage the turn moves to the next one. Risky steps such as
git pushor network calls show an approval card with the exact command. One Rust binary with SQLite and the web app embedded, no telemetry.
OpenAmer
Python · Apache-2.0 · 🟡 active
Windows-native agent runtime that operates the real desktop (filesystem, terminal, GUI, browser over the Chrome DevTools Protocol) and runs entirely locally, with persistent memory, reusable skills, and a self-improvement loop.
- Replaces: Operator-style cloud computer-use, Claude Desktop
- Backends: Any OpenAI-compatible API, Ollama, local models
- Edge: Cognition tools (
think/learn/remember/trigger/heartbeat) run in-process rather than as subprocess hops; a single 10-subsystem heartbeat replaces a pile of individual cron jobs; instances route work to each other peer-to-peer over an A2A mesh, with every action recorded in an outcome ledger so claims are checkable.
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.
Jet Browser
JavaScript + Rust · Apache-2.0 · Self-hosted runtime · 🟡 active
Gives repository-aware coding agents one isolated WPE WebKit session for deterministic browser verification.
- Replaces: Browserbase when the requirement is a self-hosted, single-session verification runtime rather than a managed browser service.
- Edge: uses WPE WebKit instead of Chromium/CDP and keeps one ordered JSONL command loop alive across native pointer and keyboard input, DOM checks, and PNG capture. The standalone smoke flow can run against an offline fixture with container networking disabled, and the repository publishes its benchmark method, raw samples, and limitations.
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.
System One API
TypeScript · OSS · 🟡 early (≈2 GitHub stars as of 2026-10)
Multi-provider API and TypeScript SDK (@system-one-ai/core) for building AI agents and LLM workflows with swappable model backends.
- Docs: https://system-one.dev/en/api
- Edge: Provider-swappable agent/LLM API surface without locking to a single vendor. Early-stage — stars≈2; listing for discoverability, not as a mature peer of LangGraph/CrewAI yet.
Agent Skills & Package Management
Tools for publishing, versioning, discovering, and installing reusable instructions and configuration across AI coding assistants.
AIPM
TypeScript · Apache-2.0 · CLI + registry · 🟡 active
Package manager and public registry for reusable AI skills, prompts, rules, MCP setup, and tool files.
- Edge: One versioned package can target Codex, Claude Code, and Cursor through adapters, while the lockfile records exact installed versions for repeatable team setup.
drevon
TypeScript · MIT · CLI · 🟡 active
npx drevon init turns any directory into an AI workspace with one shared config, persistent cross-session memory, prompts and skills.
- Backends: Claude Code, Codex, Copilot, Cursor, Windsurf, Cline, Aider and Continue
- Edge: One shared config plus persistent cross-session memory, prompts and skills serve all of these assistants from a single directory, instead of maintaining each tool’s setup separately.
aident-skill
Shell · MIT · Agent skill + CLI · 🟡 active
Installable agent skill and CLI (@aident-ai/cli) that teach coding agents to use Aident Loadout for connected work apps and 400+ ready-made Skills. The skill and CLI are MIT; the Loadout service they call is proprietary (freemium, pay-as-you-go).
- Replaces: Manual MCP credentials configuration, fragmented per-agent tool setups
- Backends: Codex, Claude Code, Cursor, OpenCode, OpenClaw and other MCP clients
- Edge: One CLI command installs a single canonical skill copy and repairs every detected filesystem-backed agent host, so all assistants on a machine share the same connected accounts. Credentials stay in a vault (agents receive results, not raw keys), and every action call lands in an audit log.
Archcore
Go · Apache-2.0 · CLI + MCP server + agent plugin · 🟡 active
Git-native context engineering and spec-driven development for AI coding agents.
- Replaces: Manual prompt engineering, scattered context docs, unversioned rule files
- Backends: Claude Code, Codex, Cursor and GitHub Copilot
- Edge: The CLI keeps specs, architecture decisions, rules, plans, and project knowledge in
.archcore/, versioned with your code, and serves the relevant context to coding agents through MCP and integrations.
looot-skills
Shell · MIT · Agent skills · 🟡 active
Agent skills (SKILL.md) that teach coding agents to run looot data jobs such as work email lookup, company enrichment, Google SERP and web page to markdown. The skills are MIT; the looot service they call is proprietary and prepaid, with no free tier.
- Replaces: Per-vendor API integrations and a separate key for each data provider
- Backends: Claude Code, Codex, Cursor and other MCP clients
- Edge: One API key and one prepaid balance cover 300+ data providers. The agent sees the price before each run, and a failed call costs $0.
Muster
Rust · Apache-2.0 · CLI + web UI + stdio MCP server · 🟡 active
Local-first configuration, Agent Skills, MCP server, and encrypted secrets manager for AI coding agents backed by a single Git repository.
- Replaces: Ad-hoc dotfiles symlinks, manual per-agent MCP/skill setup, and cloud secret managers for agent setups
- Backends: Claude Code, Codex, OpenCode, Antigravity CLI, and Pi (plus experimental Hermes Agent)
- Edge: Per-machine
ageencryption keys in the same Git repo with no external server or daemon,skills.lockSHA-256 content-hash verification on sync, read-only/proposal-onlymuster mcpstdio server with allowlist-gated secret reveal, and--format jsonenvelopes across CLI commands.
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.
Kilobat CLI
Swift · GPL-3.0-only · macOS CLI / TUI / MCP · 🟠 experimental
Network diagnostics and per-app traffic monitoring for a Mac, with JSON output and a local stdio MCP server for coding agents.
- Edge:
kilobat why <host> --jsonseparates network, proxy, DNS, IP and server checks before an agent starts changing application code. The same native executable serves MCP tools withkilobat mcp, without a separate Node or Python server. - Known limits: macOS 14+ only; Homebrew builds from source and requires Xcode 16+. Wi-Fi names need the companion’s Location permission, and traffic history needs recorded data. Network blocking requires the separately proprietary desktop app; diagnostics contact the targets being checked.
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.
Oh My Android
Swift · MIT · macOS app / MCP · 🟡 active
Native macOS control panel for the Android Emulator and adb devices, with a built-in stdio MCP server that lets coding agents see and drive the device.
- Edge:
screenshotis scaled to 1 px = 1 dp andget_uireturns a compact UI tree with refs (about 10× smaller than rawuiautomatorXML), so positions match layout code and the agent can tap by ref. The same 18 tools switch dark mode, font scale, locale/RTL, TalkBack and network, and read logcat, SharedPreferences and SQLite, on emulators and USB or Wi-Fi phones; the server is one native binary with no runtime dependencies and no network access. Known limit: macOS 26+ on Apple silicon only.
Screenpipe
Rust + TypeScript · Screenpipe Commercial License (source-available, not OSI) · Desktop + MCP + local API · 🟡 active
Captures screen text and audio history so agents can retrieve context from past debugging sessions, documentation, and meetings.
- Edge: Searches captured activity across apps with time and app filters, rather than relying on manually pasted context. MCP requires a running Screenpipe recorder and local API key; desktop Settings > Connections configures the connection. Raw history stays local by default, while configured cloud AI, transcription, sync, and integrations can send context off-device.
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.
SandBase CLI
TypeScript · Apache-2.0 · CLI + local MCP · 🟡 active
Open-source AI CLI and local MCP server that connects coding clients—Claude Code, Cursor, Codex, ChatGPT, Hermes, OpenClaw, and more—to 2,000+ models and APIs, with OAuth and config rollback.
- Replaces: per-client provider wiring and one-off OpenAI-compatible proxies when you need MCP-native setup across many coding agents
- Backends: 2,000+ models/APIs through SandBase routing
- Edge: One local MCP/CLI configures ~25 clients against a shared model catalog; OAuth plus rollback lets you switch providers without hand-editing each client’s config.
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.
ContextStream
Rust · MIT · MCP · 🟡 active
Shared project context and semantic code search over MCP for AI coding agents.
- Replaces: single-editor indexes and lost per-session context
- Backends: local OSS server (
@contextstream/mcp-server) or hosted remote MCP (https://mcp.contextstream.io/mcp) - Edge: shared project context across MCP clients not locked to one editor
mcpreflight
JavaScript · MIT · CLI · 🟠 experimental
Read-only preflight inspector and linter for MCP tool schemas and x402 HTTP payment-required endpoints with GitHub Actions CI support.
- Replaces: Manual curl inspection, ad-hoc JSON schema validation for MCP endpoints
- Edge: Runs zero-dependency preflight checks without credentials, verifying discovery manifests (
/.well-known/mcp/server.json) and SHA-256 body digests before clients or payment buyers connect.
Folio Wiki
TypeScript · MIT · Self-hosted / Docker + MCP · 🟡 active
Team wiki whose pages are Markdown files in a Git repository, with a built-in MCP server that lets coding agents search, read and edit pages, data tables and whiteboards.
- Replaces: Confluence and Notion as the place where an agent finds team conventions, runbooks and decisions
- Edge: The MCP server ships inside the app (Streamable HTTP, OAuth 2.1 or a personal access token) and acts with the signed-in user’s rights. Agent edits land in Git history under that user’s name, so they can be reviewed and reverted like any commit.
sqlite-graph-memory
Python · MIT · MCP server + CLI · 🟡 active
Persistent memory for MCP clients over any folder of markdown notes, Obsidian vaults included, stored in one local SQLite file.
- Replaces: Hosted agent-memory services, when the memory should stay in your own notes
- Edge: Vector search finds the entry points, then the
[[wikilinks]]already in the notes act as the graph, so no graph database or ETL pass is needed. In the project’s 202-note bench vault, a note the vector pass misses in its top 12 comes in second through one graph hop.
BrewPage MCP
TypeScript · MIT · MCP server (stdio + remote) · 🟡 active
MCP server that lets an agent publish HTML pages, Markdown, multi-file static sites, files, JSON documents and key-value entries and get back a shareable HTTPS link. Source-available note: the server is MIT, the hosting service it talks to (brewpage.app) is proprietary and free.
- Replaces: Pasting agent output into a Gist, pastebin or a manual Netlify Drop upload when a human needs to open it in a browser
- Edge: 20 tools cover publish, update, read and delete per resource type with an owner token, so an agent can hand over a rendered report as a link without an account or API key. The same tools are served as a remote Streamable HTTP endpoint at
https://brewpage.app/mcp. Known limits: publications expire (default 15 days, up to 30, 90 with a free profile) and size caps apply (5 MB per page or file, 20 MB per site).
Local Inference Engines
Run models on your own hardware.
Ollama
Go · MIT · 🟢 stable
Download and run open models with one command. The default entry point to local LLMs.
- Replaces: OpenAI API (for local workloads)
- Edge:
ollama run <model>and you’re done — it handles fetching, quantization, GPU offload, and serving an OpenAI-compatible API. The largest model library and the widest tool support of any local runtime.
llama.cpp
C/C++ · MIT · 🟢 stable
The inference engine most local tooling is built on. Runs LLMs on CPU, CUDA, Metal, ROCm, Vulkan, and more.
- Edge: Extreme portability — a laptop, a Raspberry Pi, a Mac Studio, a server farm. GGUF quantization is the reason a large model fits on consumer hardware.
Jan
TypeScript · AGPL-3.0 · Desktop · 🟢 stable
Offline ChatGPT alternative that runs entirely on your machine.
- Replaces: ChatGPT desktop, LM Studio (which is only partially open)
- Edge: Fully open desktop UX with local-first data storage, plus an optional OpenAI-compatible local server.
MLC LLM
Python + C++ · Apache-2.0 · 🟢 stable
Universal LLM deployment engine — native GPU acceleration on iOS, Android, desktop, and the browser.
- Replaces: Ollama (on mobile), cloud inference for on-device apps
- Edge: the only serious path to running an LLM on a phone’s GPU. Known weakness: model support is limited to what’s been compiled for the target, and when compilation or inference fails the errors are opaque.
WebLLM
TypeScript · Apache-2.0 · 🟢 stable
LLM inference entirely in the browser via WebGPU.
- Edge: no server, no API key, no data leaving the tab — which makes a whole class of privacy-sensitive apps possible. Known weakness: requires WebGPU, so Safari and Firefox support is the limiting factor, and out-of-memory device-lost errors are common on modest GPUs.
llamafile
C/C++ · Apache-2.0 · 🟢 stable
Distribute an entire LLM as one executable file that runs on multiple OSes without installation.
- Edge: Unbeatable for shipping a model to a non-technical user. One file. Double-click. Done.
Rapid-MLX
Python · Apache-2.0 · 🟡 active
OpenAI-compatible inference server built specifically for Apple Silicon, on Apple’s MLX framework.
- Replaces: Ollama / LM Studio (on a Mac)
- Edge: MLX-native quantization tuned for the unified-memory envelope, with grammar-constrained tool calling, reasoning separation, and vision — verified end-to-end against Claude Code, Cursor, Aider and Codex.
brew install rapid-mlx, thenrapid-mlx serve <model>.
Inference Servers & Gateways
Serving models at scale.
vLLM
Python + CUDA · Apache-2.0 · 🟢 stable
High-throughput, memory-efficient inference and serving engine — the de facto standard for self-hosted production LLM serving.
- Replaces: OpenAI API, Together AI
- Edge: PagedAttention plus continuous batching gives order-of-magnitude throughput gains over naive serving. Tensor/pipeline parallelism scales across GPUs; the OpenAI-compatible API means clients need no changes.
SGLang
Python · Apache-2.0 · 🟢 stable
Fast serving framework with RadixAttention prefix caching and a structured generation language.
- Edge: Wins on workloads with heavy shared prefixes (agents, few-shot, multi-turn) where prefix-cache reuse dominates. Excellent constrained-decoding support.
LocalAI
Go · MIT · 🟢 stable
Drop-in replacement for the OpenAI API that runs locally across many backends and modalities — text, image, audio, embeddings.
- Replaces: OpenAI API, ElevenLabs API
- Edge: One server, many backends (llama.cpp, vLLM, transformers, whisper, diffusers). No GPU required. Point your existing OpenAI SDK at it and change nothing else.
Text Generation Inference
Rust + Python · Apache-2.0 · 🟢 stable
Hugging Face’s production serving stack — the engine behind their inference endpoints.
- Edge: Battle-tested Rust web server, token streaming, and tight integration with the HF ecosystem.
Ray
Python · Apache-2.0 · 🟢 stable
Distributed compute framework for scaling AI workloads — training, tuning, and multi-model serving via Ray Serve.
- Edge: For when one model on one box is no longer the problem. Model composition and autoscaling across a cluster.
Unified AI System
TypeScript + JavaScript · Apache-2.0 · Self-hosted gateway + CLI · 🟡 active
Terminal-first AI gateway that puts provider routing, governed agent and knowledge contracts, an HTTP API, and Codex MCP tools behind one self-hosted service.
- Replaces: ad hoc provider-specific proxy scripts when evaluating a local AI gateway control plane
- Backends: deterministic local fake provider by default; configurable adapters for NVIDIA and OpenAI-compatible upstream providers
- Edge: A fresh clone can prove the complete chat and MCP paths without credentials, while the CLI refuses to send when a real provider may be active unless the operator supplies
--allow-real-providerfor that command. Public-clone and container smoke checks keep the credential-free path under CI.
Bifrost
Go · Apache-2.0 · Self-hosted gateway · 🟢 stable
OpenAI-compatible AI gateway for routing requests across multiple model providers with failover, guardrails, usage controls, observability, and MCP support.
- Replaces: provider-specific AI API integrations and proxy scripts
- Edge: Go-native gateway with one OpenAI-compatible endpoint, automatic failover and load balancing, plus governance and telemetry controls for production traffic.
Chat UIs & Frontends
Open WebUI
Python + Svelte · BSD-3-Clause (with branding clause) · 🟢 stable
Feature-rich, self-hosted AI interface — the default UI for Ollama and OpenAI-compatible backends.
- Replaces: ChatGPT Plus, Claude Pro
- Edge: Multi-user with RBAC, built-in RAG over uploaded documents, web search, image generation, voice, and a Python function/pipeline plugin system. Runs fully offline.
LibreChat
TypeScript · MIT · 🟢 stable
Every AI provider in one polished ChatGPT-style interface.
- Replaces: ChatGPT Plus, Poe
- Edge: Multi-provider in a single conversation, agents, code interpreter, artifacts, MCP support, and genuinely good multi-user auth. MIT with no branding restrictions.
Lobe Chat
TypeScript · Apache-2.0 (with conditions) · 🟢 stable
Modern chat framework with a plugin and agent-market ecosystem.
- Edge: The best-looking option, with PWA and mobile support plus one-click Vercel deploy.
AnythingLLM
JavaScript · MIT · 🟢 stable
All-in-one desktop and Docker app: chat with your documents, with agents and multi-user workspaces built in.
- Edge: Batteries-included RAG — embedder, vector DB, and UI ship together. Fastest path from “I have PDFs” to “I can ask them questions.”
Artifact Relay
Python + HTML · MIT · Server + Hermes plugin · 🟢 stable
Self-hosted delivery surface for publishing long Markdown and standalone HTML results from AI agents to private, mobile-friendly pages.
- Replaces: private pastebins and chat-bound artifact viewers
- Edge: Publisher and viewer credentials are separate trust boundaries. Markdown is sanitized, standalone HTML runs in a sandboxed iframe, and optional share links can be scoped and revoked without exposing the publishing credential.
ThoughtDAG
TypeScript · MIT · Web · 🟠 experimental
A local-first visual LLM workspace where graph edges define what context the model receives.
- Replaces: linear chat interfaces for long-running LLM research
- Backends: Ollama and OpenAI-compatible endpoints
- Edge: Graph edges are execution semantics, not decoration: traversing a node’s upstream DAG constructs the message history for the next request, so users can branch, merge, and prune context explicitly.
Persona
TypeScript · MIT · 🟡 active
Local-first workspace combining notes, tasks, and AI chat in your browser on your machine.
- Replaces: Notion AI, Obsidian + Copilot plugin
- Edge: Plain markdown files on disk — no accounts, no cloud, no database. The AI reads and edits your actual workspace files. Supports Ollama for fully local inference.
Aleph
TypeScript · Apache-2.0 · macOS / Apple silicon desktop · 🟡 active
An AI workspace for bringing model providers, tools, and files together across focused workspaces and reusable agents.
- Replaces: ChatGPT Desktop or Claude Desktop for users who want to configure their own agents, tools, and workflows.
- Backends: User-configured model API providers and installed, authenticated CLI providers such as Claude Code and Codex; availability depends on setup.
- Edge: The Workshop lets users compose agents, equip them with tools, and arrange reusable workflows visually, making the harness inspectable and changeable.
Vector Databases
Qdrant
Rust · Apache-2.0 · 🟢 stable
Vector search engine with rich payload filtering, built for production.
- Replaces: Pinecone
- Edge: Written in Rust — predictable latency under load. Scalar/product/binary quantization cuts RAM dramatically. Filtered search stays accurate instead of degrading like naive pre/post-filtering.
Milvus
Go + C++ · Apache-2.0 · 🟢 stable
Distributed vector database built for billion-scale workloads.
- Edge: Separated storage and compute, GPU indexing — the heaviest-duty option when the corpus genuinely is enormous. Milvus Lite covers local dev.
Weaviate
Go · BSD-3-Clause · 🟢 stable
Vector database with built-in vectorization modules and a GraphQL API.
- Edge: Module system embeds data for you at ingest. Native hybrid (BM25 + vector) search and multi-tenancy.
Chroma
Rust + Python · Apache-2.0 · 🟢 stable
The batteries-included embedding database for AI applications.
- Edge:
pip install chromadband you have a working vector store in four lines. The right default for prototypes; scale out later if you must.
pgvector
C · PostgreSQL License · 🟢 stable
Vector similarity search inside PostgreSQL.
- Edge: No new infrastructure. Your embeddings live next to your relational data with real transactions, joins, and backups. Start here unless you’ve measured a reason not to.
MongrelDB
Rust · MIT OR Apache-2.0 · Embedded + server · 🟠 experimental
Columnar database with AI-native retrieval — dense ANN, sparse vectors, full-text, and metadata filters in one transactional engine.
- Replaces: Pinecone + a separate operational DB for RAG/agent memory
- Edge: Not a pure vector store — dense ANN, sparse, and full-text indexes share one transactional row store, so hybrid search with RRF fusion runs without a separate vector service, keeping SQL, encryption-at-rest, and multi-user access. Companion MongrelDB Viewer for schema, SQL, and ANN exploration.
Embeddings & Rerankers
The retrieval quality layer. Swapping your embedding model usually beats swapping your vector database.
FlagEmbedding / BGE
Python · MIT · 🟢 stable
The BGE family — BGE-M3 embeddings and the BGE reranker models.
- Replaces: OpenAI text-embedding-3, Cohere Embed, Cohere Rerank
- Edge: BGE-M3 does dense, sparse (lexical), and multi-vector retrieval from one model across 100+ languages, so you get hybrid search without running two systems. Pairing BGE-M3 with a BGE reranker is the default open retrieval stack, and it runs on your own hardware with no per-query cost.
Sentence Transformers
Python · Apache-2.0 · 🟢 stable
The library for computing, training, and fine-tuning text embeddings.
- Edge: the interface almost every open embedding model ships against — learn it once and every model on Hugging Face is available. Fine-tuning an embedding model on your own domain is usually the single highest-leverage RAG improvement, and this is how you do it.
RAG Frameworks
LlamaIndex
Python + TypeScript · MIT · 🟢 stable
The data framework for LLM applications — ingestion, indexing, retrieval, and agentic workflows over your data.
- Edge: Hundreds of data connectors (LlamaHub) and the deepest library of retrieval strategies — hierarchical, recursive, hybrid, auto-merging. When naive top-k retrieval isn’t good enough, the fix is usually already implemented here.
RAGFlow
Python · Apache-2.0 · 🟢 stable
RAG engine built on deep document understanding — layout-aware parsing of PDFs, tables, and scans.
- Edge: Document parsing is where most RAG systems actually fail. RAGFlow treats it as the core problem and shows you citation-grounded chunks so you can debug retrieval visually.
Dify
Python + TypeScript · Apache-2.0 (with conditions) · 🟢 stable
Production-ready platform for agentic workflows — visual builder, RAG pipeline, model management, and observability in one.
- Replaces: OpenAI GPTs platform, Vertex AI Agent Builder
- Edge: Non-engineers can build and ship an internal AI tool without touching code, while engineers keep API access to everything. Self-hosted, so your data stays put.
Docling
Python · MIT · 🟢 stable
Parse PDF, DOCX, PPTX, HTML, and images into structured, LLM-ready formats.
- Edge: Layout and table-structure models that handle real-world documents. Plugs directly into LlamaIndex and LangChain.
Unstructured
Python · Apache-2.0 · 🟢 stable
Preprocessing library for ingesting unstructured documents into ML pipelines.
- Edge: Broadest format coverage. The workhorse behind many production ingestion pipelines.
LLMSlim
Python · MIT · library + CLI · 🟡 active
Fits retrieved documents, chat history and tool output into a token budget before the model call, with drop-in compressors for LangChain, LlamaIndex and Haystack.
- Edge: The default mode is extractive and runs no model: it keeps sentences from your input, chosen by query relevance (BM25), so the same input always gives the same context and nothing is paraphrased. Retrieved text is treated as untrusted, so imperative wording inside a document is never force-kept.
Fine-Tuning & Training
Unsloth
Python · Apache-2.0 · 🟢 stable
Fine-tune LLMs roughly 2x faster with far less VRAM, without accuracy loss.
- Edge: Hand-written Triton kernels and a manual backprop engine. Makes fine-tuning a mid-size model on a single free Colab GPU realistic instead of aspirational.
Axolotl
Python · Apache-2.0 · 🟢 stable
Post-training framework configured entirely through YAML — full fine-tune, LoRA, QLoRA, DPO, ORPO, and more.
- Edge: One config file describes the entire run, which makes experiments reproducible and diffable in git.
LLaMA-Factory
Python · Apache-2.0 · 🟢 stable
Unified fine-tuning for 100+ models, with a web UI.
- Edge: Zero-code training via LlamaBoard. The widest model coverage of any tuning toolkit.
PEFT
Python · Apache-2.0 · 🟢 stable
Hugging Face’s parameter-efficient fine-tuning library — LoRA, QLoRA, adapters, prompt tuning.
- Edge: The reference implementation everything else builds on. Integrates directly with Transformers, Accelerate, and TRL.
Distilabel
Python · Apache-2.0 · 🟢 stable
Synthetic data pipelines for SFT and preference tuning, from the Argilla team.
- Edge: treats dataset generation as a reproducible pipeline rather than a pile of one-off scripts, and loops through Argilla so a human can curate what the model generated. The bottleneck in fine-tuning is almost always data, not compute.
TRL
Python · Apache-2.0 · 🟢 stable
Train transformer models with reinforcement learning — SFT, DPO, GRPO, reward modeling.
- Edge: The standard path from a base model to an aligned, instruction-following one.
Fuuga
F# · Unlicense · Library + CLI · 🟡 active
Builds, pre-trains, fine-tunes and serves LLMs in F#/.NET on TorchSharp, with no Python.
- Edge: One typed .NET codebase covers the whole pipeline (BPE tokenizer, ingestion, pre-training, LoRA/QLoRA/DPO/GRPO, donor-weight import from Hugging Face safetensors and GGUF, RAG, GGUF export for llama.cpp/Ollama) on CPU or CUDA, so a .NET shop can train and run models offline without a Python stack.
Evals, Testing & Guardrails
promptfoo
TypeScript · MIT · 🟢 stable
Test and evaluate prompts, agents, and RAG systems — plus LLM red teaming and vulnerability scanning.
- Edge: Declarative test cases in YAML that run in CI. Side-by-side model comparison plus adversarial red-teaming in one tool. Local-first — your prompts never leave your machine.
Cage
TypeScript · MIT · CLI + agent hooks · 🟡 active
Deterministic contract harness that links Markdown specs to TypeScript implementations, invariant-linked tests, and review freshness.
- Replaces: Manual spec-to-code and test-traceability checklists
- Backends: Claude Code, Codex
- Edge: Parses
*.cage.mdxspecs into TypeScript contract checks, tracks@invariant/@coverslinks, and fingerprints spec, code, test, and import material to detect stale reviews. It does not run tests or prove semantic correctness.
agent-qa
TypeScript · FSL-1.1-ALv2 (fair-code; converts to Apache-2.0) · CLI, dashboard, MCP · 🟠 experimental
The self-improving QA agent for software teams, with natural-language web and mobile tests that adapt when user interfaces change.
- Backends: OpenAI- and Anthropic-compatible endpoints, Gemini, and local models
- Edge: Stores product, suite, test, and healed-step observations as versioned execution memory, then reuses that context on later runs. Ships a dashboard, CLI, MCP server, and three agent skills in one repository.
ClawBench
Python · Apache-2.0 · Docker/browser harness · 🟡 active
Evaluate web agents on 153 everyday tasks across 144 live websites, with the final submission request intercepted to keep runs side-effect-free.
- Edge: Captures session replay, screenshots, HTTP traffic, browser actions, and agent messages in one reproducible run, making failures diagnosable beyond a final pass/fail score.
WebsiteBench
Python · Apache-2.0 (code) · Harbor/Docker benchmark · 🟠 experimental
Evaluate coding agents reconstructing full-stack websites through browser exploration.
- Edge: Uses native Harbor task directories, an explicit candidate compile/runtime contract and a separate no-network verifier; complete task artifacts follow the linked HF access process.
DeepEval
Python · Apache-2.0 · 🟢 stable
“Pytest for LLMs” — unit-test LLM outputs with research-backed metrics.
- Edge: Feels like a normal test suite. G-Eval, faithfulness, answer relevancy, hallucination, and RAG-specific metrics run locally on the model of your choice.
Ragas
Python · Apache-2.0 · 🟢 stable
Evaluation toolkit for RAG pipelines.
- Edge: Splits retrieval quality from generation quality, so you know which half to fix. Can synthesize a test set from your own documents.
Guardrails
Python · Apache-2.0 · 🟢 stable
Add input/output validators to LLM applications — structure, safety, PII, and custom rules.
- Edge: Validators are composable and re-ask the model on failure rather than just erroring out.
NeMo Guardrails
Python · Apache-2.0 · 🟢 stable
Programmable rails for conversational systems, defined in the Colang modeling language.
- Edge: Dialogue-level control — keep a bot on topic, block jailbreaks, enforce a conversation flow.
Garak
Python · Apache-2.0 · 🟢 stable
LLM vulnerability scanner — probes for prompt injection, jailbreaks, data leakage, and toxicity.
- Edge:
nmapfor language models. Run it before you ship, not after the incident.
YYLO Benchmark
TypeScript · MIT · CLI · 🟡 active
Thin trusted-host experiment runner for historical Ledger tasks, supplied coding prompts, and workflows — compare models, harnesses and configurations, then evaluate retained outputs with different checks or judges later.
- Replaces: Ad-hoc multi-model coding-agent experiment scripts
- Backends: Runs selected coding-agent harnesses locally; tests require no paid provider calls
- Edge: Reviewed cases fan out to independent attempts whose retained outputs are re-evaluated later with new checks or judges — comparison rows stay separate from judge opinions, and the runner never chooses a winner.
Ponder
JavaScript · MIT · CLI + Agent skill · 🟡 active
Zero-dependency cognitive verification CLI and agent skill that enforces an 8-stage deliberation protocol and a mathematical convergence gate before an AI agent finishes a review or code change.
- Replaces: Ad-hoc single-pass LLM self-review prompts and manual review checklists
- Backends: Claude Code, Cursor, Codex, OpenClaw, and any terminal-capable coding agent
- Edge: Tracks explicit work units, predictions, adversarial lens evaluations (
skeptic,builder,dreamer,empath), and per-pass deltas in.ponder/sessions/, requiring 100% unit coverage and bounded novelty and churn beforeponder verifyexits 0. It verifies coverage and convergence of the agent’s deliberation state rather than executing application test suites.
Observability & LLMOps
Langfuse
TypeScript · MIT (core) · 🟢 stable
Open-source LLM engineering platform — tracing, evals, prompt management, and cost tracking.
- Replaces: LangSmith
- Edge: MIT-licensed core that you can genuinely self-host. Framework-agnostic via OpenTelemetry. Nested traces make multi-agent debugging tractable, and prompt versioning decouples prompt changes from deploys.
Phoenix
Python + TypeScript · Elastic-2.0 · 🟢 stable
AI observability and evaluation, built on OpenTelemetry and OpenInference.
- Edge: Runs in a notebook for local debugging or as a server for production. Strong embedding-drift and retrieval-quality visualizations.
OpenLLMetry
Python + TypeScript · Apache-2.0 · 🟢 stable
OpenTelemetry instrumentation for LLM applications.
- Edge: Standards-based — ship traces to Datadog, Honeycomb, Grafana, or whatever you already run. No new observability vendor.
agent-watch
POSIX shell · MIT · CLI · 🟠 experimental
Monitors background Claude Code and Codex jobs as RUNNING, DONE, FAILED, or STALL from process, exit-code, and log-tail signals.
- Edge: Separates transport failures from credential failures before workers start by probing without credentials in the child process, then runs the optional auth probe only after reachability succeeds.
Helicone
TypeScript · Apache-2.0 · 🟢 stable
Observability platform for LLM apps — one-line proxy integration, caching, and rate limiting.
- Edge: Change your base URL and you have logging. Lowest-friction start of any tool in this section.
Mydentify AI Model Cost Calculator
JavaScript · MIT · Browser app · 🟠 experimental
Dependency-free browser calculator for estimating AI model API costs from request volume, input and output tokens, cached input, and fixed per-request charges.
- Edge: Runs locally without API keys, accounts, cookies, analytics, or server-side processing. The tested formula separates cached from uncached input and keeps provider-specific pricing assumptions visible so estimates can be reviewed before a real bill is incurred.
OrcaReplay
TypeScript · Apache-2.0 · 🟢 stable
Records a coding agent’s exchange with its model provider and replays the run offline with no model called.
- Edge: The other tools here tell you what happened; this one runs it again. Replay serves the recorded turns with no provider contacted and nothing spent, and
--from N --model Mreplays a prefix then continues on a different model, so the model is the only variable. Captures at the HTTP boundary rather than through instrumentation — aider, OpenHands and goose from the sections above are covered, along with Claude Code and the Vercel AI SDK. The trace format is specified separately under CC BY 4.0, so a recording outlives the CLI.
Speech, Vision & Multimodal
Whisper / faster-whisper / whisper.cpp
MIT · 🟢 stable
Speech-to-text: the original model, the CTranslate2 port (substantially faster), and the C++ port (runs anywhere).
- Replaces: Google Speech-to-Text, AssemblyAI
- Edge: State-of-the-art multilingual ASR for free, on your own hardware.
whisper.cppruns real-time transcription on a laptop CPU.
WhisperX
Python · BSD-2-Clause · 🟢 stable
Whisper plus word-level timestamps and speaker diarization.
- Edge: If you need to know who said what, when — subtitles, meeting notes — this is the one.
Yap MCP
JavaScript · MIT · MCP server + CLI · 🟠 experimental
Local MCP server and CLI that transcribes audio and video files on your own computer with NVIDIA Parakeet TDT v3 through sherpa-onnx, so a coding agent can read a recording without a speech API.
- Replaces: cloud speech-to-text APIs (AssemblyAI, Google Speech-to-Text) for agent transcription tasks
- Edge: Runs from
npxon the CPU with no API key, account or upload, and one multilingual model covers 25 European languages with automatic language detection. Known weakness: the first run downloads a model of about 670 MB, and itssearch_dictationstool only returns data when the closed-source Yap desktop app is installed.
Kokoro / Piper
Apache-2.0 / GPL-3.0 · 🟢 stable
Text-to-speech. Kokoro is a tiny (~82M parameter) model with quality far above its weight class; Piper is optimized for devices as small as a Raspberry Pi.
- Replaces: ElevenLabs
- Edge: Real-time TTS on CPU. Kokoro’s small footprint makes it viable to bundle inside an app.
Pipecat
Python · Library · 🟢 stable
Framework for real-time voice and multimodal conversational agents.
- Replaces: Vapi, Retell
- Edge: pluggable STT/TTS/LLM stages over WebRTC, plus speech-to-speech model support, so you can assemble a voice agent from open parts instead of renting a platform. Known weakness: maintainers’ own issue tracker documents pipeline freezes, zombie function-call handlers after timeout, and multi-second latency in production. The linear pipeline model also fits multi-party conversation badly. Expect real engineering effort.
LiveKit Agents
Python + Node · Apache-2.0 · Framework · 🟢 stable
Realtime agent framework built on LiveKit’s WebRTC infrastructure.
- Replaces: Vapi, Retell
- Edge: the room/participant model handles multi-party and interruption natively, where a linear pipeline has to fake it. If your voice agent needs more than one human in the call, start here rather than with a pipeline framework.
ComfyUI
Python · GPL-3.0 · 🟢 stable
Node-based interface for diffusion models — image, video, and audio generation pipelines.
- Replaces: Midjourney, DALL·E
- Edge: The graph is the program — every step is inspectable and reproducible, and workflows are shareable as JSON. Supports essentially every open image/video model within days of release.
Breatic
TypeScript · Elastic-2.0 (source-available, not OSI) · Web application / internal deployment · 🟡 active
Collaborative creation workspace with shared documents, AI media canvases, and project-aware agent proposals reviewed by people.
- Replaces: Separate brief documents and media-reference boards within a creative project; no full proprietary-suite replacement is claimed.
- Backends: Configured AI model providers; Cloudflare R2 storage is required by the documented setup.
- Edge: Document and canvas Spaces share project context, with Yjs/Hocuspocus collaborative state and explicit review before agent-proposed document changes are applied. This is an application implementation to inspect and deploy internally, not a model, coding agent, or promise to solve every concurrent-edit edge case.
Surya
Python · GPL-3.0 (commercial exceptions) · 🟡 active
Document OCR, layout analysis, and reading-order detection in 90+ languages.
- Edge: Layout, reading order, and table structure — not just raw character recognition. Essential upstream of any document RAG.
Low-Code / Visual Builders
n8n
TypeScript · Sustainable Use License (fair-code, source-available) · 🟢 stable
Workflow automation with native AI agent nodes — hundreds of integrations, self-hostable.
- Replaces: Zapier, Make
- Edge: Drop to JavaScript in any node when the visual builder runs out. AI agent nodes make it a legitimate agent runtime, not just a trigger-action tool. Note: fair-code, not OSI-approved — read the license before commercial use.
Flowise
TypeScript · Apache-2.0 (with conditions) · 🟢 stable
Drag-and-drop builder for LLM flows and agents.
- Edge: Fastest way to prototype a RAG chatbot visually and expose it as an API or embeddable widget.
Langflow
Python · MIT · 🟢 stable
Visual framework for building multi-agent and RAG applications.
- Edge: Every visual component maps to real Python you can export and own. A good bridge between prototype and production code.
Open-Source Alternatives Cheat Sheet
| You’re paying for | Use instead |
|---|---|
| GitHub Copilot | Continue, Tabby, aider |
| Cursor / Windsurf | Cline, OpenCode, Continue, BitFun, Atomic Agent |
| Devin | OpenHands, Goose, SWE-agent, LoopTroop, 5dive |
| CodeRabbit / Copilot code review | CodeOtter |
| Claude Design / Figma Make | Open Design |
| ChatGPT desktop / Copilot assistant | OpenClaw, Hermes Agent |
| Bolt.new / v0 / Lovable | bolt.diy, OpenUI, Dyad |
| ChatGPT Plus / Claude Pro | Open WebUI, LibreChat, Jan |
| OpenAI API (inference) | vLLM, Ollama, LocalAI, SGLang |
| OpenAI Assistants API | Letta, Dify |
| Pinecone | Qdrant, pgvector, Chroma, MongrelDB |
| LangSmith | Langfuse, Phoenix |
| OpenRouter | LiteLLM proxy |
| ElevenLabs | Kokoro, Piper |
| AssemblyAI / Deepgram | faster-whisper, WhisperX |
| Midjourney / DALL·E | ComfyUI |
| Zapier / Make | n8n |
| Vapi / Retell | LiveKit Agents, Pipecat |
| Cohere Embed / Rerank | FlagEmbedding / BGE |
| Browserbase / Stagehand | browser-use, Jet Browser, Skyvern |
| OpenAI GPTs platform | Dify, Flowise |
Choosing Your Stack
Start small. Every layer below is optional until it isn’t.
Solo developer, local-first, zero API cost
Ollama → Continue (editor) + aider (terminal) → Open WebUI (chat)
Small team shipping an AI product
LiteLLM proxy → LangGraph or CrewAI → pgvector → Langfuse → promptfoo in CI
Enterprise, self-hosted, compliance-bound
vLLM (own GPUs) → LiteLLM (keys/budgets) → Qdrant → Dify or LangGraph
→ Langfuse (tracing) → Garak + NeMo Guardrails (safety)
Document-heavy RAG
Docling or RAGFlow (parsing) → LlamaIndex (retrieval) → Qdrant → Ragas (eval)
Three rules that save the most time:
- Put a gateway in front of your models from day one. LiteLLM costs an afternoon and buys you provider switching, budgets, and fallbacks forever.
- Use Postgres + pgvector until you have measured a reason not to. Most “we need a vector database” problems are actually retrieval-quality problems.
- Add tracing before you add features. Debugging an untraced multi-agent system is guesswork.
Contributing
PRs welcome. See CONTRIBUTING.md.
The bar for inclusion:
- OSI-approved license (source-available tools are allowed but must be labeled)
- Meaningfully maintained — commits within the last 6 months
- Solves a problem a developer actually has
- The entry explains why you’d choose it, not just what it does
Contributors
License
To the extent possible under law, contributors have waived all copyright and related rights to this work.
