UncannyPrompt: Open-Source AI Prompt Management for Teams An open-source, self-hosted platform (with a free SaaS alternative) to help teams manage their AI workflows with more control

Over the last two years, prompts have become part of the daily routine of many teams working with generative AI. Not as a formal discipline, and not only in the “prompt engineering” sense we often see in talks and articles: more simply, people started keeping, and in many cases sharing, the instructions that worked.

This “save and share” approach usually takes shape without a precise plan. A prompt written to summarize support tickets starts circulating within the team and ends up being used by everyone; a code review prompt, refined after a few attempts, becomes a standard practice before closing the work; a set of stylistic rules prepared by the Head of Marketing gradually becomes the organization’s tone of voice reference and is shared with the whole department. At the beginning, it feels like common sense: people keep what works best and, when useful, make it available to others. Over time, though, that material starts moving around in a less orderly way than we would like: inevitably, those prompts are copied into different tools, adjusted by different people, and reused in workflows that, in the meantime, have become part of daily work. What initially looked like a temporary note ends up carrying much more weight.

The problem is that many teams keep treating these prompts as scattered notes: they remain in chat histories, private documents, browser bookmarks, internal wikis, shared drives, Notion pages, Slack messages, GitHub issues, or, worse, in the memory of the person who wrote “the good version” two months earlier. The result is that, when that prompt needs to be used or updated, nobody is really sure which version is current.

This kind of problem is certainly not new to software developers: it is very similar to what source code looked like before source control systems became the standard. Copied files, alternative versions, untracked changes, uncertainty about which version was the right one: it is no accident that Git and other SCM tools became part of the basic infrastructure of any development team. Precisely for this reason, developers tend to feel the problem less: they are used to versioning what matters, and quite often they end up putting prompts under source control as well. For people who are not used to those tools, the most practical alternative is usually cloud file hosting and sharing services such as Google Drive, Microsoft OneDrive, and similar platforms. Some even end up using Password Managers such as LastPass or Bitwarden, which, for better or worse, provide a structure of items, or entries, that can be grouped by tenant, workspace, category, and tag, and can be adapted to prompts without too much effort.

All these approaches, from Git/Gist to cloud drives and password managers, can certainly work, but they remain compromises, designed to solve different problems. On closer inspection, none of them provides all the capabilities needed to manage AI prompts efficiently, including: a structured catalog, ideally organized by team, project, folder, tag, and prompt status; version history, designed to distinguish meaningful changes from simple metadata updates; reusable variables and templates, to avoid almost identical copies of the same prompt with values changed by hand; granular permissions, not only at file or folder level, but also across prompts, projects, and shared libraries; revocable and expiring public links, useful when a prompt needs to be shared outside the team without losing control completely; audit trails and traceability, to know who created, modified, shared, restored, or used a prompt; a clear and repeatable variable resolution process, with different values for users, projects, workspaces, or organizations; a model designed for reuse, rather than for storing generic files or disconnected text fragments; and so on.

UncannyPrompt was created to fill this gap: a structured place to organize, version, share, resolve, and reuse AI prompts across teams, tenants, workspaces, and projects, managing them as shared, versioned, and governable assets.

The project is available in two ways: organizations that want full control can install it as a self-hosted open-source application, while teams that prefer not to maintain their own deployment can use the managed SaaS version (free plan available) through the official website at uncannyprompt.com.

The open-source repository is available on GitHub at github.com/Ryadel/UncannyPrompt, and the project is released under MIT License, so it can be inspected, self-hosted, modified, and adapted by anyone.

What is UncannyPrompt?

The first versions of many useful prompts are written in a hurry. Someone needs to summarize a customer thread, normalize a messy specification, generate a test plan, extract risks from a document, rewrite content in a specific style, or produce a checklist from internal procedures. The prompt works, gets copied, slightly changed, shared with a colleague, pasted into another tool, then adapted again.

That is fine for experimentation. It becomes painful when the prompt turns into something the team depends on.

Once prompts start supporting repeatable work, teams need a few things that ordinary notes and chat histories do not provide well: ownership, history, access control, variables, sharing rules, auditability, and a way to understand which version is the one people should actually use.

UncannyPrompt gives teams a deliberate place to manage that prompt knowledge, instead of letting it grow informally across private tools and scattered documents.

Self-Hosted or SaaS

UncannyPrompt supports two adoption models, because not every team has the same operational requirements.

The self-hosted version is designed for teams that want direct control over infrastructure, data, authentication, configuration, backups, and deployment. It can be installed from the open-source repository and run with Docker Compose, or adapted to a production container environment when the project moves beyond local evaluation.

The SaaS version, available at uncannyprompt.com, is meant for teams that want the same prompt management capabilities without maintaining their own server, database, upgrades, or hosting environment.

In both cases, the purpose is the same: treat prompts as reusable team assets, not as snippets lost inside personal workflows.

Main Features

UncannyPrompt organizes prompts through a clear hierarchy: tenants contain workspaces, workspaces contain projects, and projects contain folders and prompts. This structure makes it possible to separate personal, team, and organization-level prompt libraries while keeping ownership and access rules explicit.

Prompts can be tagged, favorited, pinned, versioned, shared, copied, restored, resolved with variables, and exposed through public links when needed. The goal is to make prompt management  as easy as possible, thanks to the following features:

• Prompt catalog: organize prompts by tenant, workspace, project, and folder, with tags, notes, favorites, pins, and status metadata.
• Version history: preserve meaningful prompt changes through immutable versions, and restore previous versions when needed.
• Variable resolution: define reusable placeholders and resolve them by scope, such as prompt, project, workspace, tenant, user, or system defaults.
• Sharing and access control: combine tenant membership with project, folder, and prompt-level grants.
• Public links: expose selected prompts through revocable and expiring public URLs.
• Authentication: support browser sessions, API keys, Google OAuth, Microsoft Entra ID, and GitHub OAuth.
• Security hardening: include CSRF protection, rate limiting, secure headers, token hashing, encrypted secret variables, and authenticated Swagger.
• Audit and observability: record important activity through audit events, structured logs, OpenTelemetry instrumentation, and health checks.

Prompt Versioning

Versioning is one of the first things teams miss when prompts leave the experimentation phase.

A prompt may start as a simple instruction, then receive a better output format, more constraints, a stricter tone, a new validation step, or a section that handles edge cases discovered during real use. Those changes matter. If a prompt drives a repeatable workflow, the team should be able to understand how it evolved and, when needed, return to a previous version.

UncannyPrompt creates the first version when a prompt is created. Later, a new version is recorded when the prompt content changes or when explicit version metadata, such as a label or changelog, is provided.

This keeps version history focused on meaningful changes instead of filling it with every small metadata update. When a previous version is restored, the historical content becomes the current prompt content through the normal versioning flow, without rewriting old history.

Reusable Templates with Variables

Many prompts are useful because their structure stays the same while some values change. A support prompt may need the customer name, ticket text, product area, or escalation policy. A development prompt may depend on the programming language, repository conventions, framework version, or preferred testing style. A marketing prompt may change based on audience, channel, campaign, or tone.

Copying and editing those values by hand works for a while, then becomes error-prone. It also makes prompts harder to share, because each team starts maintaining its own slightly different copy.

UncannyPrompt supports variable definitions and scoped variable values. When a prompt is resolved, the system applies an explicit precedence model, from the most specific value to broader defaults. Resolution is read-only: it produces usable prompt text without changing the original prompt or creating a new version.

Secret variable values are encrypted before persistence and decrypted only when needed for authorized resolution. This is useful when a prompt template needs sensitive context but the underlying value should not be stored or displayed as plain text.

Sharing and Access Control

Prompt sharing looks simple until teams need to control who can see, edit, copy, or expose a prompt outside the organization. In small groups, informal sharing may be enough. In larger environments, especially when prompts include internal procedures or sensitive templates, access rules need to be explicit.

UncannyPrompt separates authentication from authorization. Users can sign in through configured identity providers or API keys, while permissions are enforced locally through platform roles, tenant roles, and resource-specific grants.

Tenant membership defines baseline access. Share grants provide more precise access to projects, folder subtrees, or individual prompts. Listing and access checks are applied through application services and SQL-level authorization queries, reducing the risk of accidental cross-tenant data exposure.

Public links provide anonymous access to selected prompts, but they are still validated carefully. Links can expire, be revoked, or be deleted, and successful public access is recorded in the audit trail.

Self-Hosted Version

The fastest way to try UncannyPrompt locally is with Docker Compose:

By default, the web application is exposed at:

For local development, SQL Server can run in Docker while the WebApp runs from the IDE or command line:

This gives developers a quick path for evaluating the application, inspecting the codebase, and adapting the deployment model to their own environment.

Technology Stack

UncannyPrompt is built with .NET 10, ASP.NET Core Razor Pages, EF Core, SQL Server, Tailwind CSS, DaisyUI, Alpine.js, Serilog, OpenTelemetry, xUnit, and Docker Compose.

The codebase follows a layered architecture. The Domain layer contains entities and enums. The Application layer contains use cases, DTOs, service interfaces, and authorization logic. The Infrastructure layer implements EF Core persistence, SQL Server migrations, repositories, configuration, hashing, and encryption. The WebApp hosts the Razor Pages UI, REST controllers, authentication, middleware, Swagger, and static assets.

This structure is intentionally conventional. For a tool that manages operational knowledge, I prefer boring and understandable boundaries over clever abstractions. The application should be easy to inspect, easy to run locally, and easy to adapt when a team needs to integrate it with existing infrastructure.

Open Source and MIT Licensed

The self-hosted edition of UncannyPrompt is open source and released under the MIT License. This allows developers and organizations to use it, inspect it, modify it, self-host it, and adapt it to their own workflows with minimal licensing restrictions.

This matters for teams that want to keep prompt libraries, internal procedures, sensitive templates, and operational knowledge under their own control. A prompt library can reveal quite a lot about how a company works: support procedures, decision criteria, escalation paths, customer handling rules, internal terminology, coding conventions, compliance checks. Keeping that knowledge visible and governable is often more important than it may seem at the beginning.

Who It Is For

UncannyPrompt is useful for teams that rely on AI prompts as part of repeatable work, especially when those prompts are shared, improved, reviewed, and reused by more than one person.

Typical use cases include:

• software teams managing prompts for code review, documentation, test generation, refactoring, and release notes;
• support teams that use prompts to summarize tickets, classify issues, draft replies, or extract escalation signals;
• content and marketing teams maintaining prompts for tone-of-voice checks, campaign drafts, localization, and repurposing;
• product teams working with user feedback, research notes, specifications, and competitive analysis;
• consultants and agencies that need reusable prompt libraries across customers, projects, or internal teams;
• internal automation teams that want prompt templates to be traceable, versioned, and easier to govern.

It can also be a useful reference project for developers interested in a modern .NET application with layered architecture, Docker-based setup, SQL Server persistence, authentication integration, application services, tests, security hardening, and production-oriented configuration.

Conclusions

Prompts are no longer just temporary text fragments. For many teams, they are becoming reusable assets that deserve structure, history, access control, and auditability.

UncannyPrompt was built around that idea. It provides a shared place for prompt libraries, versioning, variables, access rules, public links, and operational visibility, while giving teams the choice between a self-hosted open-source edition and a managed SaaS version.

If your team already uses prompts as part of daily work, the next step is usually not writing more prompts. It is making the good ones easier to find, improve, reuse, and control.

References

• UncannyPrompt GitHub Repository - official open-source repository for the self-hosted edition.
• UncannyPrompt official website - managed SaaS version and project landing page.
• .NET documentation - official Microsoft documentation for the .NET platform.
• ASP.NET Core documentation - official Microsoft documentation for ASP.NET Core web applications.
• Entity Framework Core documentation - official Microsoft documentation for EF Core persistence and migrations.
• SQL Server documentation - official Microsoft documentation for SQL Server.
• Microsoft Entra ID documentation - official Microsoft documentation for identity and access management.
• OpenTelemetry documentation - official documentation for instrumentation, traces, metrics, and logs.
• Docker Compose documentation - official documentation for defining and running multi-container applications.