Best Open-Source AI Projects to Contribute to in 2026

The best open-source AI projects to contribute to in 2026 are vLLM, promptfoo, LangChain, DSPy, OLMo-core, Future AGI, Langfuse and GEPA. Each one matches a skill you might want to build and shows a current path from issue to reviewed pull request. We compared them with a GitHub snapshot from 23 October 2026: license, open newcomer labels, pull requests merged in the previous 30 days, contribution guides, and code-of-conduct coverage.

The result: vLLM has the clearest large-project newcomer surface; promptfoo has strong evaluation-focused throughput; GEPA offers a smaller codebase; and Future AGI has the most open good-first-issue labels in this set. Stars did not determine the picks.

Disclosure: Future AGI publishes this blog and maintains one of the eight repositories. We ran the same five-signal check on it as on the other seven.

Which Open-Source AI Project Fits Your Goal?

If none of those domains interests you, do not force the match. Contributing to a tool you already use is usually better than chasing a famous repository you will stop reading after one weekend. Then search that tool’s issue tracker for the same newcomer labels the table counts.

How Did We Evaluate Contributor Fit?

We used the Contributor-Fit Scorecard, a reproducible five-signal check.

Signal 1: The License Is Clear

A repository must have an identifiable open-source license. MIT and Apache-2.0 are easy for many companies, but copyleft licenses are valid open source too. The open-source software license guide explains the trade-offs. A missing license is different from a license you would not choose.

Signal 2: Work Is Happening Now

We checked the latest push and pull requests merged from 23 September through 23 October 2026. Merged-PR totals include maintainers, bots, and internal contributors, so they measure repository throughput rather than the odds that a stranger’s patch gets accepted. Read them as a sign the project is alive, then open the last few merged pull requests to see who reviews outside work.

Signal 3: A Newcomer Path Exists

We counted open good first issue and help wanted labels. A zero does not make a project closed to newcomers, but it means you need a stronger understanding of the codebase before choosing work. Labels go stale, so treat them as a snapshot. Open the issue and check assignees and recent comments before starting.

Signal 4: The Contribution Process Is Written Down

Every project in the final set had a detectable contribution guide. We also checked for a code of conduct through GitHub’s community profile. Documentation reduces guesswork, though it does not prove maintainers will review your change quickly.

Signal 5: The Project Matches a Real Learning Goal

We rejected a single composite score. Ten easy documentation issues in a domain you dislike are not “better” than one hard compiler task you want to learn. The final decision is a fit judgment after the four observable checks.

What Did the Live GitHub Snapshot Show?

Method notes: stars and labels came from the GitHub API on 23 October 2026. “Merged” used the GitHub search query is:pr is:merged merged:>=2026-09-23, and for promptfoo we counted its own good-first-issue and help-wanted labels. “Not detected” means GitHub’s community profile did not return the file, which does not prove the project lacks a community policy elsewhere. Row order is not a numerical ranking.

Which Large Projects Have the Strongest Contribution Paths?

Large projects give you mature tests, review systems, and many subdomains. They also demand more reading before your first meaningful change.

vLLM: Best for Inference Systems

Best for: Python and C++ contributors interested in GPU serving, schedulers, kernels, model support, and distributed inference.

Current evidence:

• 95,139 stars and 1,825 merged PRs in the 30-day snapshot.
• 17 good-first issues and 28 help-wanted issues.
• CONTRIBUTING, code-of-conduct, and DCO files are present.

Where things get hard: a label does not make GPU code beginner-level. Start with documentation, tests, model compatibility, or a clearly scoped Python issue unless you already understand the serving path. The vLLM explainer gives you the architecture vocabulary before you open the scheduler code.

promptfoo: Best for Evaluation and Red Teaming

Best for: TypeScript contributors who want visible work in evaluation, provider adapters, assertions, security testing, and documentation.

Current evidence:

• MIT license, CONTRIBUTING guide, and code of conduct.
• 602 merged PRs in the 30-day snapshot.
• Two open good-first issues and three help-wanted issues at the snapshot time.
• Now part of OpenAI; its README says promptfoo remains open source and MIT licensed.

Where things get hard: the newcomer-label queue is short, so arrive with a reproducible bug, a provider gap, or a small documented proposal. For other eval tools, compare the open-source evaluation frameworks before deciding that promptfoo is the right codebase.

LangChain: Best for Integrations

Best for: contributors who want Python or JavaScript integrations, framework maintenance, tests, and documentation at ecosystem scale.

Current evidence:

• MIT license and a complete GitHub community profile.
• 10 open help-wanted issues.
• 221 merged PRs in the previous 30 days.

Where things get hard: the codebase is large, and an integration that looks isolated can affect shared abstractions. Read the package-specific guide and tests along with the root README. The open-source agent frameworks guide helps you decide whether LangChain’s abstractions are the ones you want to learn.

Langfuse: Best for Full-Stack Observability

Best for: TypeScript and infrastructure contributors interested in traces, prompts, datasets, evaluation workflows, and product analytics.

Current evidence:

• 36,194 stars and 906 merged PRs in the 30-day snapshot.
• A contribution guide is present.
• Core code is MIT-licensed, while enterprise modules use separate commercial terms under Langfuse’s repository license.
• Part of ClickHouse since January 2026; ClickHouse says the core stays MIT-licensed.

Where things get hard: the repository has more than one license. Check which directory your change touches and read Langfuse’s licensing notes before assuming the core MIT terms cover it. The open-source LLM observability comparison maps Langfuse against other tracing stacks.

Which Smaller Projects Let You See More of the System?

A smaller architecture is easier to hold in your head, and a focused change is more visible.

DSPy: Best for Declarative LM Programming

Best for: Python contributors interested in signatures, modules, optimizers, adapters, and research ideas expressed as software.

Current evidence:

• MIT license and 38,736 stars.
• 74 merged PRs in the 30-day snapshot.
• A contribution guide and one open help-wanted issue.

Where things get hard: optimization behavior is easy to change and hard to validate. Good contributions need a clear experiment or regression test on top of a clean implementation. Read what DSPy is and how its optimizer loop works before selecting an issue.

OLMo-core: Best for Model Training Internals

Best for: experienced Python and distributed-systems contributors who want to study a transparent training stack.

Current evidence:

• Apache-2.0 license and active development, with a push on 22 October 2026.
• 29 merged PRs in the previous 30 days.
• A contribution guide, but no newcomer labels in the snapshot.

Where things get hard: this repository suits experienced contributors more than beginners. Training code carries distributed, numerical, and reproducibility constraints that make “small” changes expensive to validate. Use the current allenai/Olmo-core repository, not the quieter legacy allenai/OLMo codebase. The open-source versus open-weight guide explains why OLMo’s release transparency matters.

Future AGI: Best Current First-Issue Inventory

Disclosure: Future AGI publishes this blog and maintains the repository. It went through the same snapshot method as the other seven.

Best for: Python, TypeScript, Go, documentation, and AI-infrastructure contributors who want a large current queue of scoped starter issues.

Current evidence:

• Apache-2.0 core license, contribution guide, and code of conduct.
• 137 open good-first issues.
• 371 merged PRs in the 30-day snapshot.

How to start: run the stack from your checkout with ./bin/dev, which the local development docs cover, including hot reload, migrations and tests. Bug fixes under about 50 lines can go straight to a pull request; larger work starts from an issue a maintainer has labelled accepted. The open-source stack for reliable AI agents shows where the repository’s eval, trace, guardrail, and optimization components fit.

GEPA: Best for a Compact Optimization Codebase

Best for: contributors interested in reflective prompt optimization and research-to-code work in a smaller Python repository.

Current evidence:

• MIT license and 7,099 stars.
• One good-first issue and 33 merged PRs in the 30-day snapshot.
• A root contribution guide plus contributor documentation.

Where things get hard: a smaller maintainer group means review capacity can vary. Read recent merged pull requests before judging response time from the star count. GEPA is an independent project. Future AGI also implements a GEPA-style optimizer in its broader optimization stack; the similar name is not an ownership relationship.

Which Other Popular Open-Source AI Projects Take Newcomers?

Ollama, Transformers, Browser Use, OpenHands and CrewAI each have more than 59,000 GitHub stars. We ran the same 23 October 2026 snapshot on all five so you can compare them on the same signals. These rows give context only; we did not run the full five-signal review on them.

CrewAI comes closest to the eight picks, with both newcomer label types open and a contribution guide. OpenHands has the larger first-issue queue, but GitHub’s community profile did not detect a contribution guide, so read a few recent merged pull requests to learn its review norms. Transformers and Browser Use had no open good-first or help-wanted issues, so arrive with a reproducible bug or a documentation fix.

How Should You Make the First Contribution?

Repository policies differ: some projects want an issue before any code, while others accept small fixes directly. Read the local rules before you pick the order.

Read the Local Rules

Start with CONTRIBUTING.md, the code of conduct, issue templates, and any CLA or DCO requirement. GitHub’s current beginner guide to open-source contributions makes the same point: understand the repository before choosing the task. If the project asks for a CLA or a DCO sign-off, set that up before you open the pull request.

Reproduce Before You Propose

Build the project, run the relevant tests, and reproduce the bug or missing behavior. Record the smallest example that demonstrates it. If the project asks for an issue or design discussion, open one. If it accepts small fixes directly, do not add process the maintainers did not request.

Keep the Patch Reviewable

Change one thing and add or update its tests. Explain what changed, why it changed, and how you verified it, with the test command and its output in the pull request description. Avoid drive-by refactors around the target. A first pull request should reduce reviewer uncertainty.

Stay Through the Review

Respond to comments, push follow-up commits, and close the loop if you can no longer continue. A useful contribution is a change the project can understand, test, maintain, and merge. Answer review questions in your own words, even when an AI tool helped write the patch.

What Changes When You Use AI to Contribute?

AI assistance is now a repository-policy question. Ghostty’s AI policy requires disclosure and expects contributors to understand the code they submit. In a different response to AI-generated noise, tldraw began closing external pull requests in January 2026, and its CONTRIBUTING file still says pull requests are turned off.

Future AGI’s contribution policy is closer to Ghostty’s. AI tools are welcome, but the pull request’s AI use: line must name the tool and how much of the change it produced, and every change must be run against the real stack with the check output pasted.

Before using an agent:

• check the repository’s AI policy and contribution guide;
• disclose assistance when required;
• verify licenses and provenance for copied code;
• run the full relevant test path;
• read and explain every changed line;
• commit to maintaining the patch through review.

Which Project Should You Choose This Week?

Before you commit a weekend, rerun the live checks: open one recent merged pull request, read the contribution policy, and confirm the issue is current. The best first project is the repository where you can explain the problem, test the fix, and stay long enough to get the change reviewed.

Pick a scoped starter task from the open good first issues in the Future AGI repository and open your first pull request this week.

Sources

• vLLM
• DSPy
• GEPA