The prompt that shipped is often not the prompt in the repository. Someone patched it during an incident, someone else edited a copy in a vendor console, and the git history that was supposed to be the record of what the model saw has quietly stopped being one. Three weeks later a customer complains about an answer, and nobody can say which wording produced it.
Every tool in this category fixes the bookkeeping half of that: versions, history, a diff. They differ on the delivery half, which is how a saved version reaches a running process and what happens between a click and every user seeing the new wording. In Langfuse, for example, splitting traffic between two versions is something your application does: the A/B testing guide labels two versions, then picks between them with random.choice([prompt_a, prompt_b]) in your own code.
TL;DR: Pydantic Logfire is our pick for teams that want promotion, percentage rollout, and targeting handled server side, and the serving version on the run's trace when the resolution wraps the run. Langfuse if you would rather spend operational time than license money, self-hosting free under MIT. LangSmith if you are already on LangChain or LangGraph. Braintrust if prompt changes should be gated on an eval suite. PromptLayer if non-engineers own the prompt text. Agenta if you version a whole configuration, not a string. Helicone only if its gateway is already on your request path, because the platform is in maintenance mode.
Last updated: August 26, 2026. Prices and capabilities were checked against each vendor's documentation on that date.
Why teams outgrow prompts in source control
A prompt in a Python string is version controlled, reviewable, and free. That is genuinely good, and plenty of teams should stop there. Four things push teams off it:
-
The change is one clause and the pipeline is forty minutes. A prompt edit carries none of the risk of a schema migration and all of the deploy cost. The rollback costs the same again, which is how a five-minute regression becomes an hour-long one.
-
The person who should write it cannot ship it. Support leads, domain experts, and PMs are often the best prompt editors on a team and the least able to open a pull request. The workaround is a shared document of "current" wording: the version control problem again, with fewer features.
-
You cannot answer "which version served this run?" Once prompts change more than weekly, a git log will not connect a bad output to the template behind it, because the deploy that carried it and the request that used it are recorded in different systems.
-
Trying a change on ten percent of traffic means writing a router. Percentage rollout, cohort targeting, and sticky assignment are solved in feature flagging and unsolved in most repositories, so teams either ship to everyone at once or build a small flag system nobody owns.
How we compared
Five criteria, stated up front, with every product measured against the same set.
- Versioning. Are saved versions immutable, and is it clear what a version does and does not capture? A version that silently includes model settings behaves differently from one that captures only template text.
- Label or environment promotion. Can you point
productionat a version without editing code, and is saving separate from promoting? Tools that conflate the two turn a draft into a release. - Rollout and targeting. Does the platform split traffic across versions and route by user attribute, or is that your application's job? This is the biggest divergence in the category.
- Evaluation against a dataset. Can you run a candidate version over representative cases and compare, in the same product, before you promote it?
- How the prompt reaches the app. Fetch and cache in an SDK, or compile in a gateway on the request path. This determines your failure mode when the vendor has a bad day, so we weighted a code-side default heavily.
One more axis that no comparison page in this category seems to ask about: if you leave, what survives? Prompt history exports are broadly available. Instrumentation is the part that does not travel, so a tool built on OpenTelemetry leaves you telemetry that outlives the vendor decision, and a proprietary SDK does not.
The best prompt management tools in 2026
1. Pydantic Logfire: best prompt management tool overall
Prompt management in Pydantic Logfire draws a hard line between authoring and releasing. Prompts are written in the UI and saved as immutable numbered versions, and the docs are blunt about scope: "A version freezes the template, nothing else." Promotion happens elsewhere, on the backing managed variable named prompt__<slug_with_underscores>, where you move a production label between versions. Because the steps are separate, saving a draft cannot change what production serves, and promoting one needs no redeploy: the application picks it up on its next resolution.
The same page holds percentage rollout and targeting rules, so a canary at ten percent, sticky per user through a targeting_key, is configuration rather than routing code. Applications read the value with pip install 'logfire[variables]' or the @pydantic/logfire-node package, an instrumented resolution emits a span, and using the resolved value as a context manager sets baggage, so the label and version that served a run sit on that run's trace next to its cost, latency, and outcome. If Logfire is unreachable, the SDK returns the default that shipped in your code. Scenarios are saved test cases that can sweep a dataset up to 500 cases per batch.
Promotion is not a separate privilege: per the access docs, saving a version and promoting one both require write_variables, so anyone who can edit can release, and a reviewer gate is yours to build around us today. Self-hosting is Enterprise only on our published plans; Langfuse and Agenta self-host free. Our prompt-workflow surface is also younger than Langfuse's or LangSmith's. And running a prompt test here spends gateway budget: a batch run calls the gateway once per case.
Best for teams that want their traces and their prompt releases in one product, and would rather configure a canary than write one.
2. Langfuse: if you would rather spend time than money to self-host
Langfuse's core is MIT licensed, and its license key page states that "All core Langfuse features and APIs are available in Langfuse OSS (MIT licensed) without any limits." Prompt management is in that core. Versions get automatic IDs, labels attach versions to environments or tenants, and rollback is setting production back to an earlier version in the UI. The SDK documents client-side caching with a 60 second TTL, serves stale copies while revalidating in the background, and takes a fallback prompt for when cache and API are both unavailable. Prompt experiments run a version over a dataset with LLM-as-a-judge or code evaluators and compare side by side.
Traffic splitting is your code, as the A/B testing guide shows. Protected prompt labels, the control that stops a member from moving production, sit outside the MIT core: self-hosting them needs an enterprise license key, and on cloud the pricing page puts protected deployment labels on the Teams add-on for Pro, or on Enterprise. Either way, the governance a self-hosted deployment most needs is the part that is not MIT. Running it also means running Postgres, ClickHouse, Redis, and object storage yourself. ClickHouse acquired Langfuse in January 2026 and committed to keeping it open source and self-hostable. That is a commitment rather than a license term. Cloud starts at $29 a month for Core with 100k units, per its pricing page.
The lane: teams with a hard data residency requirement and the appetite to operate four stateful services.
3. LangSmith: when the codebase is already LangChain or LangGraph
Every saved edit is a commit with a hash, and Environments add a promotion workflow on top: staging and production are reserved tags, you promote a commit by selecting it, each environment keeps a deployment history, and rollback is picking an earlier commit from that history. Code pulls by tag rather than hash, as in client.pull_prompt("joke-generator:production"), so the served version changes without touching the application. The prompt canvas and playground cover authoring, and testing a prompt over a dataset sits in the same product.
LangSmith is closed source, and self-hosted or hybrid deployment is Enterprise only; the Developer and Plus tiers do not offer it. Pricing is per seat, at $39 a month on Plus with 10k base traces included, so every person you want editing prompts is a paid seat. Traffic splitting between two commits is not part of the Environments feature, so a percentage canary is application code.
Right for teams whose agents are already LangChain or LangGraph, where the integration depth is worth the seat cost.
4. Braintrust: when prompt changes are gated on an eval suite
Braintrust comes at prompt management from the evaluation side. A prompt is a function you run against a dataset with scorers attached, so "does this version beat the current one" is the native question rather than an add-on. Applications call invoke() by slug or loadPrompt() to build locally, and the prompt docs note that UI changes immediately affect production behavior.
That immediacy is the tradeoff: without a version argument a prompt resolves to the latest one, so a UI save is a release. Pinning is available and is the thing to do, at which point promotion is a code change again. Environments, which separate dev, staging, and production configurations, start on Pro at $249 a month; the free Starter tier includes 1 GB of processed data and 10,000 scores with 14 day retention. Braintrust is closed source, and its self-hosting model is hybrid: the data plane runs in your cloud while the control plane, including the web UI, authentication, and metadata, stays with Braintrust.
Pick it when the release gate is an eval suite and Pro is already in the budget.
5. PromptLayer: for non-engineers who own the prompt text
The prompt registry is built for people who do not deploy code. Versions carry commit messages, release labels like prod and staging decide what runs, and the application fetches by name and label. It is one of two tools here, with ours, that documents server-side traffic splitting: dynamic release labels spread one label across versions with percentages that must add to 100, and segment rules route by request metadata such as user or company ID.
The free tier is 2.5k requests a month, and Pro is $49 a month for 5 users with overage at $0.003 per transaction, so the meter is per request rather than per seat; Team is $500 a month for 100k requests. Deployment approvals, the reviewer gate that a non-engineer editing workflow most needs, are listed under Enterprise, and so is self-hosting. The platform itself is closed source.
It fits product and support teams who own prompt wording and should never wait on an engineer to publish it.
6. Agenta: for versioning a whole configuration, not just text
Agenta treats a prompt as one field of a configuration object, so chunk size, embedding model, and temperature version alongside the template. Its concepts docs use a git shape: variants are branches with their own history of immutable commits, and development, staging, and production are deployment targets pointing at a specific commit, each keeping a deployment history you can roll back through. The core is MIT licensed with a separately licensed ee/ directory, per its LICENSE, and the self-hosted open source tier is free with unlimited runs, users, and projects, including tracing and evaluations. Cloud Pro is $29 a month for 10,000 runs.
An environment points at one commit, and the docs describe deploying to an environment rather than splitting traffic across two, so percentage canaries and attribute targeting are yours to build. It is also the smallest project here by community and integration surface, which matters most when you hit something the docs do not cover.
Suited to RAG and pipeline teams whose "prompt" is really a bundle of parameters that need to move together.
7. Helicone: only if its gateway is already on your path
Helicone puts prompts on the request path rather than in a fetch. Its prompt docs describe referencing a prompt by ID with an environment and runtime inputs, which the AI Gateway compiles, so there is nothing to cache or fall back from. Versions, custom environments, and instant rollback are all there, the repository is Apache 2.0, and the free Hobby tier carries 10,000 requests a month.
Helicone was acquired by Mintlify, and the company's own announcement says services "will remain live for the foreseeable future in maintenance mode," meaning security updates, new models, and bug fixes rather than new capability. No end-of-life date is published. Its Experiments feature also carries a deprecation notice saying it "will be removed from the platform on September 1st, 2025." The page is still published, so confirm what is live before you plan around it, but a feature under a removal notice is not one to build a comparison workflow on. A maintenance-mode vendor on your synchronous request path is a different risk from one beside your traces, and that is the deciding fact here rather than any feature.
For teams already routing production traffic through Helicone that want prompt delivery without a migration this quarter.
Comparison at a glance
| Tool | License | Self-host | Versioning | Label or environment promotion | Rollout and targeting | Eval integration | Free tier | Paid entry |
|---|---|---|---|---|---|---|---|---|
| Pydantic Logfire | Proprietary platform, open-source SDKs | Enterprise only | Immutable, numbered, template text only | Move a label on the managed variable, no redeploy | Percentage rollout plus attribute targeting, server side | Scenarios and datasets, up to 500 cases per batch | Personal: 10M records/mo, hard capped at $0 | Team $49/mo |
| Langfuse | MIT core, ee/ under separate license |
Yes, free, all core features | Auto version IDs, full history | Labels moved in UI or SDK | Traffic split written in your application code | Prompt experiments over datasets, LLM and code judges | Hobby: 50k units/mo, 2 users | Core $29/mo |
| LangSmith | Closed source | Enterprise only | Commits with hashes | Promote a commit to staging or production |
Not part of Environments; route in your code | Datasets and experiments in-product | Developer: 5k traces/mo, 1 seat | Plus $39/seat/mo |
| Braintrust | Closed source | Data plane yours, control plane theirs | Version ID per save, pin in code | Environments start on Pro | Not documented; pin or route yourself | Datasets and scorers, native | Starter: 1 GB data, 10k scores, 14-day retention | Pro $249/mo |
| PromptLayer | Closed source | Enterprise only | Versions with commit messages | Release labels such as prod |
Percentage split plus segment rules, server side | Evaluations in-product | Free: 2.5k requests/mo, 5 users | Pro $49/mo |
| Agenta | MIT core, ee/ under separate license |
Yes, free, unlimited runs | Variants as branches, commits as versions | Deploy a commit to dev, staging, or production | Not documented; one commit per environment | Evaluations included in self-host and cloud | Hobby: 5k runs/mo, 2 users | Pro $29/mo |
| Helicone | Apache 2.0 | Yes, plus Enterprise on-prem | Versions with rollback | Environments including custom ones | Not documented | Experiments under a removal notice dated September 2025 | Hobby: 10k requests/mo | Pro $79/mo |
Cells describe each vendor's current documentation. Free tiers are quoted in each vendor's own unit, which is deliberately not comparable across rows: units, traces, runs, requests, and records count different things.
How to choose
- If a compliance rule says the data cannot leave your network: Logfire's Enterprise plan deploys into your own cluster; Langfuse and Agenta do it free, with the operational load as the price.
- If you want a ten percent canary without writing a router: Pydantic Logfire or PromptLayer, the two here with server-side splitting.
- If your release gate is an eval suite that must pass first: Braintrust, assuming Pro is already in the budget for Environments.
- If your agents are LangChain or LangGraph: LangSmith, and price in a $39 seat for every prompt editor.
- If a support lead should be able to fix wording on a Friday afternoon: PromptLayer, or Logfire if you also want the change visible on the trace.
- If the prompt is really a config bundle with retrieval parameters attached: Agenta.
- If you need to know which version served a bad answer months later: Logfire, where an instrumented resolution, used as a context manager around the run, puts the serving version on that run's trace.
- If you already proxy through Helicone: stay for now, and plan the exit deliberately rather than urgently.
When prompts in your repo are still the right call
Most teams do not need any of this yet, and the honest test is not team size but change rate.
If your prompts change less than once a week, if the only people editing them can already open a pull request, and if your deploy takes minutes rather than an hour, a string in your repository is the better tool. It is free, it is reviewed alongside the code that depends on it, it cannot drift from the tests that cover it, and there is no runtime dependency on a third party. Adding a tool at that stage buys a new service to keep up and an extra place where the truth can live.
What changes the calculation is decoupling: the moment the right editor is not the right deployer, or you want a change in front of some users and not others, the repository stops being able to express what you need. Until then, our product and every other one here is overhead.
A middle path: keep the prompt in code as the default and let a managed value override it. That is how the Logfire SDK behaves anyway, since the code-side default serves when the platform is unreachable, so the repository stays the source of truth for what the application does on a bad day.
Frequently asked questions
What is prompt management?
Storing prompt templates outside application code with version history, then controlling which version production serves. The versioning half is well solved everywhere. The controlling half, meaning promotion, rollout, targeting, and rollback, is where these tools differ.
Is prompt management the same as prompt versioning?
No. Versioning is the record of what changed. Prompt management is versioning plus the release mechanism: labels or environments that decide what is live, and ideally a way to roll a change out to part of your traffic first. A tool can version well and leave the entire release problem to you.
Which prompt management tools are open source?
Langfuse and Agenta both put their core under MIT with a separately licensed ee/ directory, and both are free to self-host. Helicone's repository is Apache 2.0. LangSmith, Braintrust, and PromptLayer are closed source. Pydantic Logfire's platform is proprietary with open-source SDKs, and self-hosting is an Enterprise option. Check the LICENSE file rather than the marketing page: "open source" and "source available" get used interchangeably in this category, and they are not the same thing.
Can I change a prompt without redeploying?
In every tool here, yes, but by different mechanisms with different blast radii. Logfire, Langfuse, LangSmith, PromptLayer, and Agenta move a label or environment pointer the running application resolves. Braintrust resolves to the latest version when none is pinned. Helicone compiles the prompt in its gateway on the request path.
How do I roll a prompt change out to ten percent of users?
Pydantic Logfire and PromptLayer do it as configuration, with percentages and cohort rules held server side. In Langfuse, LangSmith, Braintrust, and Agenta you fetch both versions and choose between them in your application, which is a small amount of code and one more thing to keep consistent across services.
Does prompt management replace evals?
No, and treating it that way is how a confident regression ships. Promotion controls blast radius; evaluation tells you whether the new version is better. Six of the seven tools here run a candidate over a dataset in-product; Helicone's docs mark Experiments as deprecated with a September 1, 2025 removal date; as of our August 2026 review the workflow pages remain published.
Try Pydantic Logfire free
The free Personal plan includes 10 million records a month, hard capped at $0, and prompt management is available on it. Save a version, move a label, and watch the rollout on the traces you already debug with. Get started, or read Your traces already know how to fix your prompt for where a new version comes from in the first place. Comparing more broadly? See Logfire vs Langfuse, Logfire vs LangSmith, Logfire vs Braintrust, and our ranking of AI agent optimization platforms.
