Stay up to date with AI tools, model releases, and developer workflows that matter.

Sources indicate that weekly. Free. One click to leave.

In a recent development, 7 Day Free Trial. Cancel Anytime.

It has been revealed that every prompt registry we tested can change a prompt in a running TypeScript app, roll it back, and give production and staging different versions. LangSmith's prompt hub, Langfuse, Phoenix and AcruxCore all passed those three tests. The real differences show up elsewhere: which template syntax each one accepts, how many npm packages it pulls in, how long a change takes to reach the app, and what happens when the registry is down.

Sources indicate that we tested all of this with one small app and one prompt, which has a condition and a loop. Git files served as the baseline. Every number below comes from a recorded run.

It has been revealed that most teams start with prompts in code: a template string, or a .txt file next to the code that uses it. That works until a product manager wants to change one sentence, and the change has to wait for a full release.

Industry observers note that A prompt registry moves the text out of the deploy. The app fetches the prompt by name and by a label such as production. You change which version the label points to, and the app picks up the upcoming text without a deploy.

LangSmith's prompt hub is the best-known registry, but it is not the only one. Several of the LangSmith alternatives also manage prompts, and three of them are open source and self-hostable: Langfuse, Phoenix and AcruxCore. We covered how those tools handle tracing in Self-Hosted LangSmith Alternatives: 4 Tools Tested on One TypeScript Agent. This article covers prompts only.

In a recent development, every tool got the same prompt, support-reply. Its template takes three variables: a customer name, a plan, and a list of help articles. It has one condition: a priority line appears only for premium customers. It also has one loop: one line per help article. In Jinja2 syntax, the template looks like this:.

One help article contains the text Settings > Export. We included it on purpose, to catch any tool that HTML-escapes > into >.

Every tool then ran the same sequence from a TypeScript script:.

Recent findings suggest that each tool used its own documented TypeScript SDK. The four registries passed all six steps. The rest of this article covers how each one got there, and what it cost.

Keeping prompts in the repository costs almost nothing. The template sits in prompts/support-reply.njk, and nunjucks, the JavaScript port of Jinja2, renders it:.

The autoescape: false line matters. Our first version called nunjucks.renderString() directly, and the test failed. The default environment HTML-escapes its output, so Settings > Export reached the model as Settings > Export. Escaping is correct for web pages and wrong for prompts.

Git gives you full Jinja2, code review on every prompt change, and history in the same place as the code. What it can't do is change a prompt in a running app. Every edit, and every rollback, waits for a deploy.

LangSmith stores a prompt as a serialized LangChain object (ChatPromptTemplate), not as plain text. LangSmith's own documentation notes you must use the LangChain npm package to pull prompts in TypeScript (Manage prompts programmatically). So a plain TypeScript app that uses the openai package still needs langchain and @langchain/core:.

Sources indicate that those three packages installed 23 packages and 70 MB. Most of the size is @langchain/* (27 MB) and js-tiktoken (22 MB).

Sources indicate that templates. In TypeScript, LangChain accepts f-string and mustache templates. Mustache sections ({{#docs}}…{{/docs}}) handled our loop. Mustache has no ==, though, so the premium check became an is_premium boolean computed in code. We also tried templateFormat: "jinja2", which LangChain's Python package supports. In TypeScript it threw DEFAULT_PARSER_MAPPING[templateFormat] is not a function.

Industry observers note that labels and rollback. production and staging are reserved tags, and the documentation moves them in the UI. The langsmith JavaScript client has no public method that moves a tag. Our script called the same REST route the SDK uses internally (POST /api/v1/repos/-//tags). It worked, but it is not a documented API.

Recent findings suggest that caching. The SDK caches prompts for 300 seconds by default. In our test, a running app saw the fresh version 300 seconds after we moved the tag.

Langfuse's TypeScript client is one package, @langfuse/client. It installed 5 packages and 8 MB:.

Creating a version, moving a label and reading by label are all public SDK calls: prompt.create, prompt.update and prompt.get (Get started with prompt management).

Templates. The documentation highlights only {{variable}} substitution. But compile() calls the mustache library, so sections worked for our loop. The type signature accepts only string values, so passing a list needed a cast. The Langfuse UI colours the section tags red, and it lists title and body as the prompt's variables, not docs or is_premium. We would not depend on behaviour the documentation doesn't promise. When we sent the Jinja2 version instead, Langfuse returned the {% if %} and {% for %} tags unchanged, with no error. The model would have received them as text.

Recent findings suggest that caching. The cache time is 60 seconds by default (Caching). Our app saw the change after 62 seconds. Langfuse is also the only client with a fallback option: a prompt string the SDK uses when it cannot reach the server on a cold start.

Sources indicate that phoenix's TypeScript client fetches a prompt by name and tag, and toSDK() converts it into the message format the openai package expects. Phoenix templates only replace variables, so the condition and the loop have to run in your code before rendering:.

That is 16 lines, against 6 to 8 for the other registries. All the extra lines are template logic that now lives in the app.

According to recent reports, templates. Phoenix offers MUSTACHE, F_STRING and NONE formats (Prompts reference). Even in MUSTACHE mode, though, rendering is a plain replacement of {{name}}. When we sent mustache sections, they came back unchanged, with no error.

Errors. getPrompt() catches every error, logs it and returns null. You can see this in the client source, src/utils/getPromptBySelector.ts. A missing prompt and an unreachable server look the same to your code, which is why the snippet checks for null.

According to recent reports, size and caching. The client installed 57 packages and 90 MB. Most of that is OpenTelemetry, which comes in through its @arizeai/phoenix-otel dependency. The client has no prompt cache, so every render is a network call. That is also why a label change highlighted up immediately: 0 seconds in our test.

AcruxCore stores Jinja2 templates and renders them on the server with nunjucks. The SDK sends the variables and gets back finished messages:.

Industry observers note that the template from the test section works as it is, condition and loop included, with no is_premium flag computed in code. A label is called an alias here, and promoteAlias() moves it (Manage prompts via the SDK). The SDK installed 3 packages and 12 MB. Most of the 12 MB is one OpenTelemetry package, @opentelemetry/semantic-conventions.

In a recent development, templates. Jinja2 only. When we committed the mustache version, AcruxCore rejected it at commit time with Template parse error: unexpected token: #. That is a clear error, but it also means that moving mustache prompts from LangSmith or Langfuse requires rewriting them.

We sent the same two templates, a Jinja2 one and a mustache one, to each tool's own renderer:.

In a recent development, the rows that matter most are the ones where the tags were left in the output, because those failures produce no error. The model receives raw template syntax, and the only symptom is a strange answer. Whatever tool you pick, test one prompt with logic in it before you move the rest.

Putting logic in the template is not automatically better. It lets someone change the condition without a deploy. It also lets them break the condition without a deploy. Keeping logic in code, as Phoenix forces you to do, puts every branch under code review and in your tests.

A registry is a newly introduced runtime dependency, so we tested an outage. The app reached each registry through a local proxy, and we switched the proxy off. A separate process then started while the registry was still unreachable.

LangSmith, Langfuse and AcruxCore keep serving the last good version while the registry is down, even after the cache time has passed. The risk is a cold start: a new container or a serverless function that boots during the outage. Langfuse's fallback option is the built-in answer to that. With the other tools, keep a copy of each prompt in your code as a fallback, which brings back part of the Git setup.

Industry observers note that keep prompts in Git if engineers make every prompt change and your deploys are quick. Set autoescape: false, and you get Jinja2, reviews and history for free.

Use LangSmith's prompt hub if you already use LangChain, or already trace with LangSmith. If your app doesn't use LangChain, budget for the extra dependency and for the tag moves that only the UI supports.

Industry observers note that use Langfuse if you want a small client, a local compile(), and a fallback for cold starts. Keep to {{variable}} substitution unless you are comfortable relying on mustache behaviour that the documentation doesn't promise.

Use Phoenix if you already use it for tracing, or if you prefer all template logic in code. Remember the null check, and that every render is a network call.

Use AcruxCore if you want real conditions and loops in the template and rendering on the server. Expect one network call per new set of variables, and a personal API key for writes.

Industry observers note that before you choose, run one of your own prompts with real logic in it through the tool's SDK, not through its playground. Two of the four registries we tested failed on template syntax without any error, and an SDK run is where you would see that.

7 Day Free Trial. Cancel Anytime.

→ Read original article