Best Open-Source Prompt Management Tools (2026)

TL;DR: The open-source prompt managers still worth using in 2026: Open Prompt Manager (nothing to host, MIT) and prompts.chat (self-hosted team library, MIT + CC0) for a saved prompt library; Langfuse and Helicone if you already run LLM observability and want prompt versioning bundled in; Promptfoo if the job is testing prompts, not storing them. Two names that keep showing up in these roundups, Agenta and Flowise, don't belong here anymore, and this piece explains exactly why.

What Counts as an Open-Source Prompt Manager?

Search for an open source prompt manager in 2026 and you get a mix of things that don't belong in the same sentence: a permissively licensed, genuinely self-hostable app; a Chrome extension whose code sits on GitHub under a license that forbids commercial use; and at least one project whose README used to describe a prompt tool and now describes something else entirely. None of that is a knock on any single project. It's what "open source" comes to mean once a marketing page stands in for an actual license file.

This piece checked the license file, the last commit date, and what each tool actually does today, for six live candidates, then looked at what self-hosting any of them really costs before you commit a team's prompt library to one.

The Open Source Initiative's definition requires a license that permits commercial use, modification and redistribution without restriction. That rules out source-available licenses written to block a competing hosted offering, and it rules out Creative Commons licenses outright: even the most permissive CC variants were written for creative works, not software, and the one a tool below actually ships under forbids commercial use explicitly. A project can be public, popular and genuinely useful without clearing that bar. It just isn't open source in the sense the term was built for, and a post that blurs the two isn't doing you a favor when you're deciding whether to build a business on top of it.

Which Open-Source Prompt Tools Are Actually Alive in 2026?

Star counts measure a launch week, not a maintenance schedule, and they age instantly. What actually tells you whether a project is alive is its last commit and its release cadence, both public on GitHub for free. Here's what six candidates looked like when checked on 3 September 2026.

Two more names show up constantly in these roundups and neither belongs in that table anymore, for two different reasons.

Agenta was, for most of its life, an open-source LLMOps platform built around prompt engineering, versioning and evaluation, exactly the category this piece covers. As of 3 September 2026 its own README describes something else: "The open-source workspace for building and running agents". It's still MIT-licensed and still commits daily, so it hasn't died. It's pivoted, fully, to building and running autonomous agents rather than managing prompts, and a post still listing it as a prompt manager is describing a product that stopped existing at some point in 2026.

Flowise is the simpler case: GitHub marks the repository archived, meaning the maintainers made it read-only. Its last commit landed 13 August 2026, three weeks before archival. An archived repo still runs if you clone it today, but nobody is fixing the next security advisory in it, and "it's on GitHub" was never a promise that stays true.

What Each Tool Actually Does

Open Prompt Manager is the most literal answer to "self-hosted": there's no server to host at all. It's a Chrome extension that keeps your prompt library in the browser's own local storage, tags and searches it, and does JSON export and import instead of cloud sync. The README states the license as MIT, though there's no LICENSE file in the repo, only that one line. It's actively maintained: the GitHub repo's last commit was 2 September 2026, one day before this was checked. If your prompts can't leave your machine, this is the tool.

prompts.chat, formerly Awesome ChatGPT Prompts, started as a GitHub markdown file in December 2022 and has since become a genuinely self-hostable app: an npx command scaffolds a Next.js and PostgreSQL deployment with your own branding, theme, and a choice of GitHub, Google, or Azure AD login. The code is MIT-licensed and the prompt data itself is dedicated to the public domain under CC0, both confirmed in the repo's LICENSE file rather than a marketing claim. It ships an MCP server too, so an agent can pull from your library directly. The last commit landed the same day this was checked. If the job is "our team needs a shared, brandable prompt library we control," this is closer to a finished product than anything else on this list.

Langfuse bills itself as an open source LLM engineering platform, and Prompt Management is one of its headline features alongside observability, evaluations and a playground. The core is MIT-licensed; a separate ee/ directory carries an Enterprise license for a handful of features, a standard open-core structure, clearly disclosed in the repo's own LICENSE file. It's been backed by ClickHouse since January 2026, the README says so directly, and it ships commits daily. docker compose up genuinely gets you a local instance in minutes, exactly as the README claims, but that's the local and dev path. Production self-hosting is a different commitment: the architecture needs Postgres for transactional data, ClickHouse for analytics, Redis for caching and queues, and S3-compatible storage for raw events, four separate services, not one container.

Helicone covers similar ground from the observability side, with a labeled Prompt Management feature for versioning prompts against production traffic. It's Apache-2.0, actively maintained (last commit 31 August 2026), and self-hosts through Docker. Its own architecture docs list five services: a frontend, a Cloudflare Worker for proxy logging, a dedicated log-collection server, Supabase for the application database, and ClickHouse for analytics, plus Minio for object storage. That's a heavier stack than Langfuse's, not a lighter one, worth knowing before you pick it purely because it's the newer name.

Promptfoo does a different job than everything else here: prompts live as version-controlled files in your own repository, and its CLI evaluates and red-teams them against real model calls, rather than storing a browsable library. It's MIT-licensed and among the most active repos in this list, with commits landing the same day this was checked. In March 2026 its founders announced Promptfoo had agreed to be acquired by OpenAI, stating plainly that Promptfoo would remain open source. If what you actually want is a saved, searchable library rather than a testing harness, this isn't your tool, even though it shows up in nearly every "open source prompt tool" list.

AI Prompt Genius is the extension most often called open source in this category, and it's worth being precise about what that means. Its README states the code is licensed under Creative Commons Attribution-NonCommercial-ShareAlike 4.0, which explicitly forbids commercial use, not an OSI-approved open-source license, whatever the general reputation suggests. It's genuinely alive, last commit 29 July 2026, still distributed under the same name, but its sync currently runs through a Google account, and the repo's own worker/README.md describes a Cloudflare Worker replacement as a scaffold that "needs your Cloudflare account to deploy and cannot be verified from the repo", not a finished self-hosting path. We cover it, and what to use instead, in more depth in AI Prompt Genius Alternatives.

Does It Matter Whether a Prompt Tool Talks to Your Coding Agent?

MCP support is becoming the dividing line in this category faster than licensing is, and it's worth checking explicitly rather than assuming every self-hosted tool has caught up. prompts.chat ships its own MCP server, so a coding agent can pull directly from your self-hosted library without a separate integration. Langfuse and Helicone both integrate with agent frameworks and gateways like LiteLLM at the observability layer, which is a different thing: they see what an agent already did, they don't feed it your saved prompts. Promptfoo is adjacent to this world too, it evaluates agent behavior, but it isn't a library an agent reads from either. Open Prompt Manager and AI Prompt Genius are both scoped to a browser tab, so neither is reachable from a terminal-based coding agent at all right now.

If the actual job is "I want Claude Code or Cursor to pull from a shared prompt library," that narrows the honest open-source field to one: prompts.chat. Everything else on this list is either a browser tool or an observability platform, and neither category was built with an agent as its primary consumer.

What Does Self-Hosting Actually Cost You?

Every self-hosted option above saves you a subscription fee. None of them saves you the underlying work, and it's worth being honest about what that work is before "free" becomes the only number you look at, an honesty most FOSS AI tools' own landing pages skip entirely.

Take Langfuse's own architecture: a production deployment needs Postgres for transactional data, ClickHouse for analytics, Redis for caching and queueing, and S3-compatible object storage for raw events and attachments. That's four stateful services to patch, back up and monitor, on top of the Langfuse containers themselves. Helicone's self-hosted architecture lists five: a frontend, a Cloudflare Worker, a dedicated log server, Supabase, ClickHouse, and Minio. Neither vendor hides this; both publish the full architecture in their own docs. What gets lost in a five-minute quick-start video is that "self-hosted in minutes" describes a local Docker Compose demo, not the thing you'd actually put a team's production data through.

Every one of those services eventually needs a version bump, a security patch, or a page at an inconvenient hour when a disk fills up. That's the honest trade against a subscription: self-hosting doesn't remove the work, it moves it onto you.

How Do You Verify Any of These Before You Commit?

Five checks, in the order that catches the most problems fastest. Run them yourself in under ten minutes for any candidate, including ones not on this list:

1. curl -s https://api.github.com/repos/<org>/<repo> | grep -E "pushed_at|archived"
2. Read the actual LICENSE file (or the README's License section) - don't trust the badge
3. Check the last 5 commits: are they features, or just dependency bumps?
4. Read the self-hosting docs for the FULL production architecture, not just the quick-start
5. Search the repo's own issues for "self-host" or "production" - see what other adopters hit

That takes ten minutes and would have caught both Agenta's pivot and Flowise's archival before either cost anyone a migration.

When Does Self-Hosting Actually Make Sense?

Self-hosting is the right call when you have a specific reason the hosted version doesn't work for you: data can't leave your infrastructure for compliance reasons, you need to modify the tool's behavior in a way no vendor will build for you, or you're already running the backing services (a team with a ClickHouse cluster for other reasons has a very different calculus than one standing one up from scratch). It's also the right call for Open Prompt Manager specifically, since there's no infrastructure decision to make at all.

Team size is a reasonable proxy, though not a perfect one. A company with a platform team already running Postgres and ClickHouse for other services can add Langfuse or Helicone to that stack at close to zero marginal ops cost, so self-hosting isn't really a separate decision for them, it's reusing what they already run. A five-person startup standing up the same stack purely to save a subscription fee is buying itself a second production system to maintain, on top of the product it's actually trying to ship.

It's the wrong call when the actual reason is "free", and you're a team of one to five people who wants a prompt library that works today without becoming anyone's part-time infrastructure job. That's a common, legitimate situation, and it's the one Prompt Architects is built for: a hosted prompt library and enhancer that syncs across ChatGPT, Claude and Gemini, with no server for you to run, patch or back up. It isn't a replacement for Langfuse if you're running production LLM evaluations, and it isn't free of the same trade-off in reverse, you're trusting us with the uptime and the security patching instead of doing it yourself. Pick based on which side of that trade you'd rather own.

If you're comparing this specifically against a Chrome-extension workflow like AI Prompt Genius rather than a self-hosted platform, the decision looks a little different again, covered in AI Prompt Genius Alternatives. And if you manage prompts as a developer working inside an IDE or MCP client day to day, Best Prompt Management Tools for Developers and Best AI Prompt Manager Extensions in 2026 cover the hosted side of that comparison in full.