Trending Open Source AI Projects on GitHub, October 2026

GitHub’s monthly trending page works for a language, because a language filter already defines the set. Open source AI asks a different question: the work spans five languages, and the useful cut is the job a repository does.

This snapshot was read from the public GitHub API on 16 October 2026, and inside each group the repositories are ordered by star count. Stars measure attention, and a skills folder can gather that attention faster than a serving engine, so the group comes before the sort. The license column is part of the ranking as well, because several of the most starred projects are fair-code, brand-restricted, or split across two licenses.

The Rust and Go roundups on this site were built from that same page, with a language filter doing the grouping. Here the eight job groups below replace the filter, and each section states the trade that separates the close options. The closing sections turn the tables into a shortlist you can run, and into a repeatable method for the next snapshot.

How to rank open source AI projects

Search topics, then assign a job

GitHub topics are the workable substitute for a language filter. Sort a topic such as ai-agents, llm, rag, local-llm, or agent-memory by stars, and keep repositories that were pushed in the last few months. Free-text search for “AI” is too wide, and the unfiltered trending page still mixes agents with unrelated tools.

Three public inputs are enough to rebuild the list. Use topic search for the pool, a scenario catalog such as Top Open Source AI for the job labels, and the repository LICENSE file for the last column. That catalog publishes a composite of its own: stars at 70 percent, contributors at 10 percent, and update recency at 20 percent. This article keeps the simpler rule, so the number in the table is the number on GitHub.

Useful starting queries:

• ai-agents topic, by stars
• llm topic, by stars
• rag topic, by stars
• agent-memory topic above 5,000 stars
• GitHub trending, monthly

Keep software, and set lists aside

A repository earns a row when someone can install it, or when it is a maintained harness that changes how an agent runs. Awesome-lists, prompt directories, and dumps of vendor system prompts collect stars and still leave nothing to deploy. They belong in a reading list, and they stay out of the tables below.

Add a trending column only from your own snapshots

The language roundups could show stars gained in a month because GitHub already computes that delta inside one language. Across these groups, a monthly delta needs two snapshots of your own. Save full_name and stargazers_count on the first of the month, then subtract. Until that series exists, total stars are the honest ranking key. “Trending” in the title means actively maintained projects with the attention to match, as of this date.

Where the projects sit

These groups are layers you can stack. A coding assistant can call a gateway, a gateway can call Ollama or vLLM, and a memory service can sit beside either of them. Two products from the same layer are usually a second opinion, and they are rarely a better architecture.

Personal AI assistants

This group is for agents that take actions on a machine or across tools, beyond a single coding session. OpenClaw leads by a wide margin. Hermes is the other general agent at this scale, and AutoGPT is the older name that is still accumulating stars while its license has split. A deeper leaderboard for this pair alone, with downloads, token share, and CVE history, is the OpenClaw vs Hermes Agent comparison.

Firecrawl is listed here because agents need pages, and it is the web-data project readers actually star. It is a tool, and the assistants call it.

OpenClaw

OpenClaw is a personal agent meant to run on your own operating system and carry out tasks, which is the plain reading of a project that calls itself an AI that does things on any platform. The star count is the largest in this article, and the MIT license is the permissive end of the set. Treat the install as a local automation runtime with broad access to the machine, and scope what it is allowed to touch before you leave it running.

Hermes Agent

Hermes Agent, from Nous Research, is a general agent designed to accumulate skills and context as it is used. It sits in the same job as OpenClaw, with a Python codebase and the same MIT terms. Choose it when you want that growth loop and you are already comfortable operating a Python agent. Running both Hermes and OpenClaw means two permission models to audit.

AutoGPT

AutoGPT is the project that made autonomous agents a mainstream GitHub category, and it is still one of the most starred names in the set. The license is no longer a single grant. Everything outside the autogpt_platform folder is MIT, and everything inside that folder is under the Polyform Shield License, which permits use but reserves the code’s commercial value to the producer. Read that split before you build a product on the platform directory.

Firecrawl

Firecrawl turns sites into data that agents can call. The star count puts it among the assistants even though the job is acquisition, which says a lot about what people are wiring up in 2026. AGPL-3.0 matters if you modify it and offer the result as a service. For a personal agent that only calls a local or vendor endpoint, the license is a smaller constraint.

AI coding assistants

Coding agents are the densest part of the 2026 list. OpenCode leads the fully open terminal and editor agents, with Codex and Gemini CLI close behind as the vendor CLIs that happen to be open source. OpenHands, Cline, and Goose are the other programs you can actually run.

Aider (49,567 stars, Apache-2.0), Continue (36,228, Apache-2.0), and Crush (28,669, FSL-1.1-MIT) are real coding tools in the next band. Crush’s license is a Functional Source License that converts to MIT on the schedule written in the file. One coding agent is plenty. A second one is for a comparison week, and after that it is configuration you have to keep in sync.

OpenCode

OpenCode is an open source coding agent with a terminal workflow and a large plugin surface. It has become the default name people cite when they want a coding agent they can inspect, and the MIT license matches that use. The repository is anomalyco/opencode. Pick it when the agent itself should be something you can patch.

Codex

Codex is OpenAI’s lightweight coding agent for the terminal, written in Rust and licensed Apache-2.0. It is the open client for a hosted model family, which is a different bargain from a local-first agent. Use it when your team already standardizes on OpenAI models and you want a CLI you can automate. The client being open does not move the model weights onto your disk.

Gemini CLI

Gemini CLI brings Gemini into the terminal as an agent, under Apache-2.0. It plays the same role as Codex for a different provider, and the TypeScript codebase is easier to embed in existing Node tooling. Choose it when Gemini is the model you already pay for. Running it beside Codex is reasonable only if each repo has one default agent.

OpenHands

OpenHands is a software-development agent with a full task loop, now published from the OpenHands organization. The MIT license and the higher-level product make it a platform choice, closer to a hosted development environment you can self-host than to a single binary. Use it when you want issues, sandboxes, and a UI around the agent. For a one-person terminal workflow, OpenCode, Codex, or Goose is the smaller install.

Cline

Cline is an autonomous coding agent that ships as an SDK, an IDE extension, or a CLI. Apache-2.0 and the editor integration make it the practical pick for people who live in VS Code and still want a library they can call. It overlaps OpenCode more than it overlaps a chat UI. Standardize on one of them per repository so reviews stay readable.

Goose

Goose is an extensible local agent that installs, edits, runs, and tests code with whatever model you point at it. The repository now lives at aaif-goose/goose, and the Rust implementation plus Apache-2.0 make it a strong workstation agent. Choose Goose when the model provider should be swappable and the agent should run on the machine that holds the code. It is a quieter star count than OpenCode, and it is a more direct fit for a local model.

Agent skills and harnesses

Topic search will put this group above several real products. Superpowers and ECC are instructions, hooks, and workflows for agents you already run. Spec Kit is GitHub’s own process toolkit for spec-driven development. They change agent behavior, and they are still software you compose with a coding assistant from the previous section.

Superpowers

Superpowers is an agentic skills framework and a software-development methodology, distributed mostly as shell and instruction files under MIT. The star count is what you get when a method spreads through coding-agent users in a few months. Install it on top of an agent you already trust, and expect to edit the skills to match the repository. The framework will follow whatever permissions that agent already has.

ECC

ECC is a harness for Claude Code, Codex, OpenCode, Cursor, and similar agents, covering skills, memory, and checks around how the agent works. It is the right shape if you want the same loop on more than one coding agent. It is also another moving layer between you and the model. Adopt it when the team has already picked the agents and wants one shared way to brief them.

Spec Kit

Spec Kit is GitHub’s toolkit for spec-driven development and the process around it. The maintainer is the platform most of these repositories already live on, and the MIT license is straightforward. Use it when you want a written spec before the agent edits code. It will stay quiet if the team treats the spec as optional paperwork.

AI memory

Memory is the layer that lets an agent resume. The starred projects split into two styles. claude-mem, Beads, and much of Hindsight attach memory to coding sessions. Mem0, Cognee, and Letta are services you call from application agents. Capture policy, dependencies, and self-hosting tradeoffs for these backends are compared in Agent Memory Providers.

Memvid (16,600 stars, Apache-2.0) and Zep (4,961 stars, Apache-2.0) are smaller options in the same job, Memvid as a single-file store and Zep as an integration-heavy memory API. One memory system per agent is the setup you can still explain later.

claude-mem

claude-mem records what a coding agent does, compresses that history, and injects the relevant part into later sessions. It talks to Claude Code, OpenClaw, Codex, Gemini CLI, Hermes, Copilot, and OpenCode, which is why it leads this group. Apache-2.0 fits a sidecar you may want to modify. Use it when the thing you keep forgetting is the coding session itself.

Mem0

Mem0 is a memory layer for agents and applications, with user, session, and agent state behind an API. It is the default name when the product is a support bot or a personal assistant, and you want that memory outside any one coding tool. Apache-2.0 and a hosted option sit side by side, so self-hosting is a choice you can make later. Prefer it over a coding-session hook when many agents should share the same facts about a user.

Hindsight

Hindsight is Vectorize’s agent memory project, aimed at agents that learn from what they have already done, and it integrates with both coding agents and application frameworks. The MIT license is the most permissive in this group. The project publishes strong benchmark claims, and those claims should be re-run on your own transcripts before you bet a product on them. Pick Hindsight when you want a dedicated memory service and you are willing to compare it with Mem0 on your data.

Cognee

Cognee builds a memory and knowledge graph that agents can query, with an emphasis on running that layer on smaller models. It overlaps Mem0 and it also overlaps the RAG tools below, because a graph of your documents behaves like both memory and retrieval. Apache-2.0 keeps the embedding path replaceable. Choose it when the facts you care about are entities and relationships, and a flat vector index has already felt too lossy.

Beads

Beads stores coding-agent tasks, plans, and dependencies as files that travel with the git branch. The repository is now gastownhall/beads, and it is the same project the January Go roundup listed under its earlier path. MIT and a git-backed store make it the memory tool that your existing review process can see. Use it when context should fork with the branch. Use claude-mem or Mem0 when the memory has to outlive a single repository.

Letta

Letta is the stateful-agent platform that grew out of MemGPT. Memory here is part of the agent runtime, so the agent manages its own context as a feature of the platform. That is a deeper commitment than dropping Mem0 under an agent you already run. Apache-2.0 applies to the open platform. Choose Letta when you want the runtime and the memory designed together, and choose Mem0 when you want memory under agents you do not intend to replace.

RAG and knowledge bases

RAG projects turn documents into a context layer. RAGFlow is the end-to-end engine people are starring. LlamaIndex is the document framework, GraphRAG is Microsoft’s graph approach, and WeKnora is Tencent’s knowledge platform, which also appeared in the January Go roundup and has kept growing.

RAGFlow

RAGFlow is a self-hosted RAG engine that parses messy documents and exposes retrieval to agents, with citations as part of the product. Apache-2.0 and a UI you can hand to a team are why it leads this group by a clear gap. Use it when the job is “put our files behind an answer box” and you want the parser, the index, and the API from one project. Reach for LlamaIndex when you are embedding retrieval inside an application you already control.

LlamaIndex

LlamaIndex is a document-processing framework for agents and RAG pipelines. It is a library with many connectors, and the MIT license fits that role. You assemble the index, the store, and the agent yourself, which is the cost of the flexibility. Choose it for product code. Choose RAGFlow when you want the same job as a service you deploy.

GraphRAG

GraphRAG builds a graph over a corpus and answers questions by walking that graph, as Microsoft Research’s open implementation of the idea. The technique itself is explained in Advanced RAG: LongRAG, Self-RAG and GraphRAG. MIT licensing makes it easy to try beside a vector pipeline. Graph construction costs more up front than a chunk-and-embed index, and it pays that cost back on questions that span many documents. Use it when the corpus has structure you are currently forcing into chunks.

WeKnora

WeKnora is Tencent’s knowledge platform for turning documents into a RAG index, an agent, and a wiki that the project describes as self-maintaining. The project license is MIT, with third-party components under their own terms. GitHub reports that license as Other, because the MIT grant sits under a Tencent preamble. It is the closest cousin to RAGFlow in this table, with a Go core. Prefer it when you want the wiki and the agent in the same box, and compare the parsers on a sample of your own PDFs before you migrate a library.

Workflow and agent builders

Builders are where a team draws the flow, or where a developer imports the framework that draws it for them. n8n is the largest by stars and the narrowest by license. Dify and Langflow are the AI-native studios. LangChain is the library underneath a great many of the others.

CrewAI (59,745 stars, MIT) and AutoGen (61,429 stars, CC-BY-4.0) belong in the same conversation as code-first multi-agent frameworks. AutoGen’s Creative Commons attribution license is unusual for a code repository, and it is worth reading before you vendor it. LangChain remains the integration surface those frameworks still meet.

n8n

n8n is a workflow platform with hundreds of integrations and native AI steps, and it is the project people mean when they want Zapier-style automation they can host. The Sustainable Use License allows internal business use, personal use, and non-commercial use. Distribution is limited to free, non-commercial copies, and files marked .ee need a separate enterprise license. It is source-available fair-code, and it is still the right tool for internal automation if those limits match how you run it.

Dify

Dify is a workspace for agent workflows and RAG pipelines, with model providers and tools in one deployable stack. The license starts from Apache-2.0 and adds conditions: operating a multi-tenant service, meaning multiple workspaces, needs a commercial license, and the console logo and copyright notice stay on the frontend. Single-tenant internal use is the case the extra clauses leave open. Choose Dify when a team needs one UI from prototype to production, and choose Langflow when the license has to stay plain MIT.

Langflow

Langflow is a visual builder for agents and RAG flows, with an MIT license and a star count essentially tied with Dify. The canvas is the product, and the generated flows are something a developer can still own. Use it when you want a diagram of the pipeline and a license a procurement checklist already understands. The trade is a younger application surface than Dify’s workspace features.

LangChain

LangChain is the agent-engineering library that most integration docs still assume. MIT and the breadth of connectors keep it in every shortlist, and the abstraction cost is real once the chain is doing something simple. Use it when you are writing application code and you want the adapters already written. Use Dify or Langflow when the deliverable is a workspace, and use a direct provider SDK when the flow is a handful of calls.

Local inference and chat interfaces

This is the layer under everything else. Ollama is the workstation runner, Transformers is the model-definition library, Open WebUI is the chat front end, llama.cpp is the portable C++ engine, and vLLM is the server engine. Hugging Face Transformers is included because so many of the other projects import it, even though you do not “run” it the way you run Ollama. API maturity, hardware support, and production readiness across the runtimes are compared in Ollama vs vLLM vs LM Studio.

Ollama

Ollama runs current open models locally behind a simple CLI and an OpenAI-compatible API. It was already a leader in the January Go roundup, and at 183,334 stars it is still the default workstation runtime. MIT and a single daemon are the reasons. Use it on a developer machine and on small servers. Move the same weights to vLLM when concurrency, batching, and GPU utilization become the problem.

Transformers

Transformers is Hugging Face’s library for defining, loading, and running models across text, vision, audio, and multimodal checkpoints. Apache-2.0 and the model hub around it make this the library the rest of the stack imports. You feel it when you are training, converting, or debugging a model. You can ignore it for a long time if Ollama or vLLM already serves the checkpoint you need.

Open WebUI

Open WebUI is the chat interface most people put in front of Ollama and OpenAI-compatible APIs. The Open WebUI License allows redistribution and then restricts branding. Above 50 end users in any rolling 30 days, you may not alter, remove, or replace the Open WebUI name and marks without written permission or an enterprise license. For a personal or small-team install that keeps the name, it is the polished front end. For a product you will rebrand, budget the enterprise conversation first. Docker deployment and the setup options are walked through in the Open WebUI guide.

llama.cpp

llama.cpp is the C and C++ inference engine that made local models practical on ordinary hardware. MIT licensing and the GGUF ecosystem are why Ollama and a crowd of smaller apps sit on top of it. Use the project directly when you want the engine, the quantization tools, or a binary with few dependencies. Use Ollama when you want that engine with model management already wrapped.

vLLM

vLLM is a high-throughput serving engine for GPUs, with continuous batching and an OpenAI-compatible API. Apache-2.0 and the deployment focus make it the server counterpart to Ollama. Star count is lower because the audience is people who run GPUs, and that audience is the one that feels the difference. Choose vLLM when more than a few concurrent sessions share one machine.

LLM gateways

A gateway is the OpenAI-compatible front door in front of many providers. LiteLLM is the common choice, New API is the self-hosted distributor, and Bifrost is the smaller high-throughput gateway. Put a gateway in the stack when you have more than one provider, a budget per key, or a need to fail over. A single local Ollama daemon does not need one.

LiteLLM

LiteLLM exposes a large set of provider APIs through one OpenAI-shaped interface, with spend tracking, retries, and guardrails. Code outside the enterprise/ directory is MIT, and that directory has its own license. The Python SDK is what application code imports, and the proxy is what the platform team runs. Use the core when you want one client for many vendors. Check the enterprise directory before you assume the whole repository is MIT.

New API

New API is a model hub that aggregates providers and re-serves them as OpenAI, Claude, or Gemini compatible endpoints. It is the gateway people deploy when they also want user accounts, quotas, and a distribution UI. AGPL-3.0 is the term that matters if you modify the hub and offer it as a service. For an internal gateway with upstream keys, it is a concrete alternative to LiteLLM’s proxy, with a Go deployment and a stricter license.

Bifrost

Bifrost is a Go gateway for models and tools, with failover, budgets, and an MCP gateway in the same process. The star count is far below LiteLLM, and the January Go roundup already had it on the trending list, so the project is younger than it is obscure. Apache-2.0 avoids the enterprise-directory split. Consider it when the gateway is on the request path of a busy service and you want a small Go binary. Keep LiteLLM when you need the long tail of provider adapters today.

A stack worth running

The tables are a map, and a workstation still needs a short list. For a local setup in October 2026, Ollama plus one coding agent covers the daily loop. Add Open WebUI if the branding clause fits the user count, Mem0 or claude-mem depending on whether memory belongs to an application or to a coding session, and RAGFlow when the documents are the product. Add LiteLLM or New API only after a second model provider shows up.

Skills packs such as Superpowers and ECC come after the agent is chosen. They are easy to star and easy to accumulate, and three harnesses on one repository will fight over the same instructions.

Keeping the ranking current

Repeat the topic queries at the top of this article, assign each new repository to one job, and re-sort that job by stars. Then open the license file. A project that jumped the table on a skills directory, a prompt list, or a weekend of attention can wait for the next snapshot before it replaces a tool you run.

Store the snapshot. A single CSV of full_name, stargazers_count, license, and pushed_at, taken monthly, turns the next edition of this page into a real trending column, the same kind of delta the language articles already show. Until then, the groups are the part that ages well, and the star counts are the part that goes stale on purpose.

Sources

Star counts, languages, and license identities were read from the GitHub repository API and the repository LICENSE files on 16 October 2026. Job labels also draw on the public scenario list at Top Open Source AI, which documents its own composite score separately from the sort used here.

• GitHub topics: ai-agents
• GitHub topics: llm
• GitHub topics: rag
• GitHub trending, monthly
• Top Open Source AI
• Polyform Shield License
• Functional Source License
• n8n: Sustainable Use License and plans
• Open WebUI License file