#3
OmniRoute is a free, open-source AI gateway that aggregates a vast ecosystem of AI providers into a single unified endpoint, letting developers route requests from any AI coding tool through one interface. Its central promise is to let users "never stop coding" by aggregating the documented free tiers of numerous providers into roughly 1.53 billion free tokens per month (steady state), potentially rising to ~2.15 billion in the first month when one-time signup credits are included. The project claims support for 290 AI providers—more than 90 of which offer free tiers—and computes its free-token figure from 43 provider pools spanning 516 models. OmniRoute connects popular AI coding tools and agents such as Claude Code, Codex, Cursor, Cline, Copilot, and Antigravity to free Claude, GPT, and Gemini models, with automatic fallback so that if one provider hits its rate limit, requests seamlessly reroute to another. It offers 19 routing strategies to distribute load intelligently across providers and pools, and starts at $0 cost to use.
A key differentiating feature is its token compression technology: a stacked "RTK + Caveman" compression approach that reduces token usage by 15–95% (averaging about 89%), helping users avoid hitting their limits and stretch free allowances much further. The project emphasizes honesty in its free-tier accounting, using pool-deduplication math where each shared pool is counted only once—noting that naively counting every rate limit 24/7 would inflate the number to roughly 10 billion, which they refuse to publish. They also flag 15 providers with restrictive Terms of Service so users can decide for themselves, and surface signup credits and permanently-free no-token-cap providers (such as SiliconFlow, Z.AI GLM-Flash, Kilo, OpenCode Zen, and Baidu) separately so they never inflate the headline figure. Notable per-model free allowances include Mistral Large 3 (1B), GPT-4o mini (150M), Gemini 2.5 Flash (60M), and Claude Sonnet 4.5 (25K). First-month signup credits are listed for providers like Vertex (300M), AgentRouter (200M), Predibase (25M), Together (25M), GLM-CN (20M), Doubao (15M), AI21 (10M), LongCat (10M), DeepSeek (5M), Hyperbolic (5M), and Nscale (5M), plus a $10 OpenRouter top-up that unlocks an additional 24M/month. These figures are re-audited every two weeks against the live catalog and can move in either direction as providers add or remove free tiers, with a live dashboard at /dashboard/free-tiers showing used and remaining tokens.
Regarding the query "a2a": OmniRoute provides a full CLI along with A2A (agent-to-agent) and MCP (Model Context Protocol) integration, positioning it as a comprehensive tool for AI agent workflows and interoperability. The project appears to be quite mature and actively maintained, distributed across multiple channels: it is available as an npm package, a Docker Hub image, and an Electron desktop application, with badges tracking npm monthly downloads, Docker pulls, and Electron downloads. It is licensed under the permissive MIT license and is local-first and privacy-focused, meaning user data and API keys stay on the user's own machine. The project supports a flagship "Combos" feature for stacking providers, runs "anywhere," and offers dashboard screenshots and demos. OmniRoute has strong signs of trending momentum: it carries a Trendshift repository badge (repository 23589), a Star History rank badge, and social star tracking, indicating rising GitHub popularity. It maintains an active community across Discord, Telegram, and WhatsApp (both global and Brazil-specific groups), and the maintainer Diego Souza promotes it via LinkedIn and GitHub. The README is exceptionally polished and heavily internationalized, available in 43 languages including English, Portuguese (Brazil and Portugal), Spanish, French, Italian, German, Dutch, Russian
MCPServingToolslocal-firstcodingworkflow-automation
★ 31,258 total+10,869 this week
#6
Openship is an open-source, self-hostable deployment platform with built-in CI/CD that automates the full lifecycle of getting an application from source code to production. Users point it at a GitHub repo, local folder, or prebuilt artifact, and Openship handles detection, building, running, routing, and TLS termination end-to-end — with zero config files required. The platform supports any stack (Node, Python, Go, Rust, PHP, Ruby, Java, .NET, Docker, monorepos) and includes full backend services: Postgres, MySQL, MongoDB, Redis, workers, WebSockets, storage, a built-in mail server with DKIM/SPF/DMARC, scheduled backups, CDN with HTTP/3 and Brotli, and real-time monitoring. It can be driven through three interfaces — a desktop app (for solo users managing servers over SSH), a web dashboard (for teams), and a CLI — plus a REST API and an MCP endpoint designed for AI agents, with strict permission re-checking and credential route exclusions. Deployment targets include Openship Cloud (managed, zero setup), any VPS (Hetzner, DigitalOcean, Linode, OVH), dedicated/bare-metal servers, and multi-server setups. The self-hosted stack runs via Docker Compose (Linux, using OpenResty for edge routing and Let's Encrypt for TLS) or in bare mode on macOS/Windows. Push-to-deploy via GitHub webhooks rebuilds only affected monorepo services. Self-hosting is free, the core is described as production-ready, and the project is actively developed with multi-node clustering noted as coming next. Its Trendshift badge and broad multilingual README signal growing international traction.
MCPAgentsAppsworkflow-automationlocal-firstsecurity
★ 8,765 total+5,305 this week
#19
OpenSEO is an open-source, pay-as-you-go alternative to expensive SEO platforms like Semrush and Ahrefs, designed for individuals and AI agents. It covers core SEO workflows including keyword research, rank tracking, competitor insights, backlink analysis, site audits, and AI visibility monitoring. A standout feature is its MCP (Model Context Protocol) server, which allows AI agents such as Claude Code, OpenClaw, and Hermes to directly consume SEO data through reusable "Agent Skills" — making it notably AI-native. Rather than bundling data costs into a subscription, OpenSEO uses a bring-your-own-key model via the DataForSEO API, so users pay only for what they use. Self-hosting is supported via Docker (for personal use) or Cloudflare (for team/internet-facing deployments). A hosted version is available at openseo.so for $10/month, with the project monetizing through a 28% markup on DataForSEO requests. The project is early-stage but actively developed, with community channels on Discord and X. Its combination of open-source flexibility, AI-agent integration, and cost transparency makes it a notable trend in the intersection of SEO tooling and agentic AI workflows.
MCPToolsAppsworkflow-automationlocal-first
★ 8,292 total+3,183 this week
#26
codebase-memory-mcp (CBM) is a high-performance code intelligence engine designed specifically for AI coding agents, built by DeusData. Its core purpose is to give large language model-driven coding assistants fast, structured access to a codebase without the token-heavy, inefficient practice of file-by-file exploration. The tool full-indexes an average repository in milliseconds and can index the Linux kernel (28 million lines of code across 75,000 files) in about 3 minutes, answering structural queries in under 1 millisecond. It ships as a single static binary with zero runtime dependencies for macOS (arm64/amd64), Linux (arm64/amd64), and Windows (amd64), requiring only a download, an `install` command, and an agent restart. The engine parses code using tree-sitter AST analysis across 158 languages, with vendored grammars compiled directly into the binary. This is further enhanced by a "Hybrid LSP" semantic type resolution layer for 10+ languages including Python, TypeScript/JavaScript/JSX/TSX, PHP, C#, Go, C, C++, Java, Kotlin, Rust, and Perl. The result is a persistent knowledge graph capturing functions, classes, call chains, HTTP routes, and cross-service links. CBM exposes 15 MCP (Model Context Protocol) tools covering search, tracing, architecture analysis, impact analysis, index-coverage checks, Cypher queries, dead code detection, cross-service HTTP linking, and ADR management. It also supports infrastructure-as-code indexing, treating Dockerfiles, Kubernetes manifests, and Kustomize overlays as graph nodes with cross-references. The project emphasizes efficiency, claiming 120x fewer tokens (roughly 3,400 tokens versus 412,000 for file-by-file search across five structural queries). Performance is enabled by a RAM-first pipeline using LZ4 compression, in-memory SQLite, and fused Aho-Corasick pattern matching, with memory released after indexing. The tool integrates with 43 supported automatic/conditional client surfaces; its `install` command auto-detects installed agents and safely configures their MCP entries, instructions, skills, and lifecycle hooks. A notable architectural feature is the Session Coordination Daemon, a single per-account background process shared across clients like Claude Code, Codex, and OpenCode. This daemon owns long-lived services such as file watchers, shared indexing jobs, and an optional UI, coordinating session lifecycle so the first session starts it and the last shuts it down. It enforces strict consistency: all active CBM processes must share the exact same version, build, coordination ABI, and canonical cache root, with an OS-level admission barrier rejecting conflicts and logging them. The native install/update/uninstall commands are a deliberate exception, publishing maintenance intent, cancelling active work, and holding exclusive barriers during binary swaps. A separate lightweight `cli` mode runs single commands locally without starting the daemon. An optional UI build embeds a 3D interactive graph visualization frontend accessible at localhost:9749. Installation is available via one-line curl scripts, PowerShell for Windows, or package managers (npm, PyPI, Go), and an auto-index option indexes new projects on first MCP connection. On maturity and trust, the project appears robust and production-oriented: it advertises 5,604 passing tests, MIT licensing, an OpenSSF Scorecard, SLSA 3 build provenance, signed and checksummed release binaries scanned by 70+ antivirus engines via VirusTotal, and fully local processing so code never leaves the user's machine. The design and benchmarks are documented in a research preprint titled "Codebase-Memory: Tree-Sitter-Based Knowledge Graphs for LLM Code Exploration via MCP" (arXiv:2603.27277), evaluated across 31 real-world repositories with reported 83% answer quality, 10x fewer tokens, and 2.1x fewer tool calls versus file-by-file
MCPToolsRetrievalcodinglocal-firstvector-database
★ 35,667 total+2,654 this week
#43
Wigolo is a local-first web intelligence layer designed specifically for AI agents, providing search, fetch, crawl, extract, cache, find-similar, research, and autonomous gather loop capabilities — all without requiring API keys, cloud dependencies, or per-query billing. The project positions itself as a serious alternative to paid web intelligence services like Tavily, Exa, and Firecrawl, rather than merely a free substitute, emphasizing that it matches their quality while keeping all data and computation on-device. It runs as an MCP (Model Context Protocol) server, a REST endpoint, or an embedded SDK, and integrates natively with a wide range of AI coding agents and frameworks including Claude Code, Cursor, Codex, Gemini CLI, VS Code, Windsurf, Zed, Antigravity, LangChain, CrewAI, LlamaIndex, Vercel AI SDK, n8n, and any MCP-compatible client.
Setup is handled via a single `npx wigolo init` command that downloads a headless browser engine and on-device models, runs a health check, and optionally wires named agents in one pass. The tool requires Node.js version 20 or higher and approximately 1.5 GB of disk space, and works on macOS, Linux, and Windows. An `--agents` flag allows simultaneous configuration of multiple coding agents, while `--interactive` and `--wizard` flags offer guided setup flows. The `npx wigolo doctor` command provides ongoing health monitoring, and the entire installation can be cleanly removed with a single uninstall command.
The core toolset includes eight primary capabilities. The `search` tool fans out queries across 18 direct engine adapters in parallel, applying rank fusion and ML reranking with explainable per-result scoring. The `fetch` tool uses a tiered router that auto-escalates from plain HTTP to a headless browser for anti-bot challenges or single-page applications, returning clean markdown with metadata. The `crawl` tool supports BFS, DFS, sitemap, and map-only strategies with robots.txt compliance. The `extract` tool pulls structured data including tables, JSON-LD, and custom JSON Schema outputs. The `cache` tool enables keyword and hybrid semantic querying of previously fetched content. The `find_similar` tool uses three-way fusion of keyword, semantic, and live web signals. The `research` tool decomposes questions into sub-queries, fetches sources, and synthesizes cited reports. The `agent` tool runs an autonomous plan-search-fetch-extract-synthesize loop with a step log and time budget. Additionally, `diff` and `watch` tools track page changes and deliver updates to webhooks.
A key differentiator is wigolo's commitment to honest, transparent output: stale cache, failed fetches, degraded backends, bot-blocked pages, and weak results are all explicitly surfaced and labeled rather than silently swallowed. Every search result carries verbatim excerpts pinned to byte-exact source spans, citation IDs, evidence scores decomposed into semantic and lexical components, and engine consensus counts. This design makes wigolo particularly well-suited for agentic workflows where the agent needs to reason about the reliability and provenance of its evidence.
The project is currently in public beta, actively shipping new features
MCPRetrievalToolslocal-firstbrowser-useworkflow-automation
★ 3,657 total+1,668 this week
#44
CodeGraph is a developer tool that adds semantic code intelligence to AI coding agents, indexing an entire codebase into a unified code graph so agents can retrieve surgical, precise context about how code fits together rather than relying on naive text search. It is designed to "supercharge" a wide range of AI coding assistants, including Claude Code, Cursor, Codex, OpenCode, Hermes Agent, Gemini, Antigravity, and Kiro, by wiring itself into each as an MCP (Model Context Protocol) server. A central selling point is that CodeGraph runs 100% locally, with its core kernel powered by Rust for performance, and it bundles its own Node.js runtime so no separate Node installation, compilation, or native build is required. The project emphasizes being the "fastest complete code graph," providing surgical context that is built around how agents actually work in practice. Installation is streamlined into a few steps: a single curl or PowerShell command grabs the correct OS-specific build, `codegraph install` auto-detects and configures the user's agents by wiring the CodeGraph MCP server into each, and `codegraph init` creates a local `.codegraph/` directory and builds the full graph for a given project in one command. A key convenience feature is auto-sync, enabled by default, which continuously watches the project and updates the graph on every file change—whether the agent edits code or the user adds, modifies, or deletes files—so the index is never stale and nothing needs to be manually re-run. The tool also offers clean lifecycle management: `codegraph upgrade` detects the installation method (bundle, npm, or npx) and updates in place with options to check or pin versions, while `codegraph uninstall` reverses the installer across every agent it configured and can optionally keep the CLI, with per-project indexes removable via `codegraph uninit`. CodeGraph advertises broad language support, treating every supported language uniformly with full structural extraction and cross-file resolution into one graph without per-language setup. The extensive list spans mainstream languages like TypeScript, JavaScript, Python, Go, Rust, Java, C#, PHP, Ruby, C, C++, Swift, Kotlin, Scala, and Dart, as well as web and framework languages such as Svelte, Vue, and Astro, and more specialized or niche languages including ArkTS, Objective-C, Metal, CUDA, Liquid, Pascal/Delphi, Lua, Luau, R, CFML, COBOL, Visual Basic .NET, Erlang, Solidity, Terraform/OpenTofu, and Nix. The project highlights framework-aware routing and mixed iOS/React Native/Expo bridging as notable capabilities, suggesting it understands cross-boundary relationships beyond plain syntax. It supports Windows, macOS, and Linux, and offers multiple integration modes including a CLI, MCP tools, and library usage, along with configuration and telemetry options. CodeGraph places emphasis on trust and supply-chain security, advertising npm provenance, signed and attested builds, and verified releases, and it is distributed under the MIT license. Beyond the current open-source CLI, the README teases an upcoming hosted "CodeGraph platform" aimed at pull-request analysis—telling teams exactly what to test, what could break, which flows are affected, and whether business logic is compromised for every PR—with an early beta waitlist available at getcodegraph.com. In terms of maturity, the project appears actively developed and polished, with cross-platform installers, upgrade/uninstall tooling, published npm packages, documentation and a dedicated website, measured cross-file coverage claims, and an active promotional presence on X (@getcodegraph). Its potential to trend stems from the intersection of several hot themes: AI coding agents are a rapidly growing category, and tools that improve agent context quality and reliability are in high demand. By supporting nearly every popular agent simultaneously, running entirely locally (appealing for privacy and enterprise use), leveraging Rust for speed, and covering an unusually broad set of languages with zero-config indexing and automatic sync
MCPRetrievalToolscodinglocal-firstsecurity
★ 62,631 total+1,652 this week
#64
DNSHE Free Domains is a public-interest free domain registration and DNS resolution service built by a Singapore-based youth team, targeting developers, students, open-source projects, and early-stage internet creators. The project offers free domain registration under several public suffixes — including `.de5.net`, `.us.ci`, `.cc.cd`, and `.bot.cd` — each tailored for specific use cases like tech portfolios, CI/CD pipelines, creative projects, and bot automation. It provides full DNS record management (A, AAAA, CNAME, MX, TXT, NS, SRV, CAA) via a dashboard and a documented API, enabling automation-friendly workflows for deployment pipelines, testing environments, and certificate management. No credit card is required for the basic tier. The repository serves as a public information hub with quick-start guidance, acceptable-use policies, abuse reporting channels, and legal notes. The project is actively maintained and notable for democratizing domain infrastructure without cost barriers, making it particularly appealing to hobbyists and open-source contributors. Its trending status likely reflects growing demand for free, developer-friendly domain services with robust DNS and API support.
MCPToolsworkflow-automation
★ 7,580 total+1,144 this week
#75
NitroStack is an enterprise-grade TypeScript framework for building production-ready MCP (Model Context Protocol) servers, targeting AI-native backend development. It takes an opinionated, batteries-included approach inspired by enterprise frameworks like NestJS, offering decorator-driven tool/resource/prompt definitions, a first-class dependency injection container with multiple lifecycle scopes, and built-in authentication supporting JWT, OAuth 2.1, and API keys. Key features include a middleware pipeline (guards, interceptors, pipes, exception filters), Zod-based end-to-end type safety, React-based UI Widgets for rich interactive tool outputs, and caching annotations — all composable via a single decorator stack with zero boilerplate. The ecosystem ships three modular packages: `@nitrostack/core`, `@nitrostack/cli`, and `@nitrostack/widgets`. Complementing the framework is NitroStudio, a dedicated desktop app for real-time tool testing, payload inspection, hot reload, and built-in AI chat against the MCP server. The project is actively maintained, open-source under Apache 2.0, and notable for riding the strong agentic-AI and MCP adoption wave, offering a structured, scalable alternative to hand-rolled MCP server boilerplate.
MCPAgentsAppsworkflow-automationsecurity
★ 2,166 total+1,001 this week
#80NEWPartial week
**opencodex** is an open-source, lightweight local proxy server that acts as a universal AI gateway, enabling OpenAI Codex, Claude Code, Claude Desktop, and Grok Build to route requests to virtually any large language model provider — not just the ones those clients natively support. The core idea is elegantly simple: two commands install and start the proxy, which then intercepts the Codex Responses API and translates it into whatever protocol or format the target provider expects. This means developers can use Claude, Gemini, Grok, GLM, DeepSeek, Kimi, Qwen, Ollama, or any OpenAI-compatible endpoint from within their existing Codex or Claude Code workflows without waiting for official integrations.
A standout feature is **cross-client subagent routing**: Claude Desktop can answer as Claude Opus and then hand off a subtask to a GPT-5.6 Sol subagent, while Grok Build can drive a session on Sol and call a Kimi K3 subagent — each side retaining its native UI. This multi-agent, cross-provider orchestration is rare and technically sophisticated for a community-built tool.
The proxy supports full-fidelity translation including streaming, tool calls, reasoning tokens, and image inputs in both directions. It ships with a web dashboard (accessible via `ocx gui` at `localhost:10100`) that supports 40+ built-in providers, auto-discovers models from `/v1/models` endpoints, and allows OAuth login for Anthropic, xAI, and Kimi. Providers can also be added via interactive CLI (`ocx init`) or by editing a JSON config file directly. Model routing uses a clean `provider/model` syntax, with smart auto-matching for bare model names (e.g., `claude-*` routes to Anthropic, `gpt-*` to OpenAI).
A particularly practical feature is the **ChatGPT/Codex account pool manager**: users can add multiple Codex accounts, and the proxy automatically routes new sessions to the lowest-usage healthy account, respects 5-hour, weekly, and 30-day quota windows, handles 429 cooldowns with failover, and pins existing threads to their originating account to prevent mid-conversation account switching — critical for long SSH, tmux, or mobile sessions.
The OpenAI provider layer is nuanced, distinguishing between a Codex-login pool mode (`openai`) and an API key mode (`openai-apikey`), with Pro virtual model tiers (e.g., `gpt-5.6-sol-pro`) that rewrite to base models with `reasoning.mode: "pro"` at the wire level. Reasoning effort controls — `low`, `medium`, `high`, `xhigh`, `max`, and `ultra` — are surfaced in the Codex App model picker, with `ultra` mapping to maximum reasoning plus proactive multi-agent delegation. GPT-5.6 Sol, Terra, and Luna are pre-seeded as catalog entries for accounts that can serve them.
Platform support is comprehensive: macOS (arm64/x64) via launchd, Linux (x64/arm64) via systemd, and Windows (x64) via Task Scheduler or optional WinSW native service — all without WSL. The tool requires only Node.js 18+ and bundles the Bun runtime automatically on install. It is published on npm as `@bitkyc08/opencodex` and documented in five languages (English, Korean
MCPAgentsServingmultimodallocal-firstworkflow-automation
★ 5,061 total+926 this week
#96
The `openai/codex-plugin-cc` repository provides an official OpenAI plugin that integrates Codex directly into Claude Code, allowing developers to run AI-powered code reviews and delegate tasks without leaving their existing Claude Code workflow. The plugin exposes several slash commands: `/codex:review` for standard read-only code reviews, `/codex:adversarial-review` for steerable, design-challenging reviews that pressure-test assumptions and tradeoffs, and `/codex:rescue` to hand off bug investigations or fixes to Codex as a subagent. Additional commands — `/codex:transfer`, `/codex:status`, `/codex:result`, and `/codex:cancel` — enable session handoffs, background job monitoring, and task cancellation. All commands support background execution, making long-running reviews and investigations non-blocking. The plugin wraps the local Codex CLI and app server, reusing existing authentication, configuration (via `config.toml`), and repository context. An optional review gate feature uses a `Stop` hook to automatically trigger a Codex review before Claude finalizes a response, though it carries a warning about potential usage drain. Requirements include Node.js 18.18+ and either a ChatGPT subscription or OpenAI API key. The project is notable for bridging two major AI coding tools — Anthropic's Claude Code and OpenAI's Codex — reflecting a cross-ecosystem trend in AI developer tooling interoperability.
MCPToolsAgentscodingworkflow-automation
★ 30,018 total+655 this week
#121NEWPartial week
Persome, developed by Intuition-Lab, is an open-source "Personal Model" that learns how an individual thinks and works by capturing focused activity on a Mac — then supplies evidence-linked context to AI coding agents like Codex, Claude Code, and Cursor via the Model Context Protocol (MCP). The project is notable for its privacy-first, fully local architecture: all data stays on the user's machine, is inspectable, correctable, exportable, and deletable, with no Full Disk Access required. Persome builds a layered semantic memory structure organized into five tiers — Points (sourced observations), Lines (relationships over time), Faces (evidence-backed patterns), Volumes (higher-order structures), and a Root (the current integrated model of the user) — forming a living, evolving personal knowledge graph. New evidence can strengthen, revise, or overturn earlier inferences, and every claim retains traceable receipts, making the system grounded rather than hallucination-prone. Key use cases include restoring work context across sessions ("continue where you left off"), autonomous background task execution within user-defined permission boundaries ("work while you sleep"), and personalizing AI agent behavior so the same prompt yields different, contextually appropriate answers for different people. The project supports macOS 13+ on both Apple Silicon (using bundled PP-OCRv6 for local OCR) and Intel (using Apple Vision framework), and integrates with hosted or local LLM providers as well as agent subscriptions from Codex, Claude Code, and Cursor. Currently at version 0.3.2, Persome is listed on the Official MCP Registry and is trending in the agent-memory space due to its unique combination of deterministic provenance, local privacy guarantees, and deep MCP-native integration for agentic workflows.
MCPAgentsRetrievallocal-firston-deviceworkflow-automation
★ 1,220 total+516 this week