Awesome Open AI Developer Tools

Awesome Open AI Developer Tools

Awesome

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:

  1. What does it do?
  2. What closed-source product does it replace?
  3. 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 LICENSE file in the repository before depending on one commercially. Where no license is shown, we have not confirmed it.


Contents


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.yml against 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 claude and codex CLIs 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.cpp fork for local quantized models, plus any OpenAI-compatible endpoint, with presets for OpenRouter, LM Studio, and Ollama Cloud
  • Edge: Ships its own llama.cpp fork 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 start freezes 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, subscribe and ask from 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.toml send 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.md brand 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 push or 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 age encryption keys in the same Git repo with no external server or daemon, skills.lock SHA-256 content-hash verification on sync, read-only/proposal-only muster mcp stdio server with allowlist-gated secret reveal, and --format json envelopes 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> --json separates network, proxy, DNS, IP and server checks before an agent starts changing application code. The same native executable serves MCP tools with kilobat 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: screenshot is scaled to 1 px = 1 dp and get_ui returns a compact UI tree with refs (about 10× smaller than raw uiautomator XML), 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, then rapid-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-provider for 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 chromadb and 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.mdx specs into TypeScript contract checks, tracks @invariant/@covers links, 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: nmap for 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 before ponder verify exits 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 M replays 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.cpp runs 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 npx on 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 its search_dictations tool 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:

  1. Put a gateway in front of your models from day one. LiteLLM costs an afternoon and buys you provider switching, budgets, and fallbacks forever.
  2. Use Postgres + pgvector until you have measured a reason not to. Most “we need a vector database” problems are actually retrieval-quality problems.
  3. 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

CC0

To the extent possible under law, contributors have waived all copyright and related rights to this work.