PromptHub: A Unified Prompt-Engineering Framework

• PromptHub is a design space that treats prompts as structured artifacts, enabling template creation, versioning, evaluation, and provenance tracking.
• It encompasses systems like PromptSource, PromptSuite, and PromptChain that facilitate prompt generation through templating, controlled perturbation, and blockchain-enabled validation.
• Applications span natural language and visual in-context learning, improving model robustness and user interactivity through modular multi-prompt fusion and recommendation.

Searching arXiv for the cited PromptHub-related papers to ground the article in current literature. PromptHub denotes, in contemporary prompt-engineering literature, both a specific framework and a broader systems concept for treating prompts as explicit computational objects, interface elements, governance units, and reusable assets. In text-centric settings, prompts are defined as mappings from dataset examples to natural-language input–target pairs, stored in repositories, generated through controlled perturbations, or recommended during interactive writing; in visual settings, prompts are image–label or image–mask demonstrations retrieved and fused for Visual In-Context Learning (VICL). Taken together, these uses suggest that PromptHub is best understood not as a single standardized platform but as a design space spanning prompt definition, storage, versioning, evaluation, recommendation, provenance, and multi-prompt fusion (Bach et al., 2022, Habba et al., 20 Jul 2025, Bara, 13 Jul 2025, Luo et al., 19 Mar 2026, Kim et al., 22 Jan 2026).

1. Formalizations of the prompt object

A central formalization comes from PromptSource, which treats a prompt as a function over a dataset example. If $\mathcal{X}$ is the space of dataset examples and $\mathcal{S}_{in}\times\mathcal{S}_{out}$ is the space of prompt-input and prompt-target strings, then each prompt template $\tau$ is defined as

$$\tau:\mathcal{X}\to\mathcal{S}_{in}\times\mathcal{S}_{out}.$$

The same object can be represented as a single string $s\in\mathcal{S}$ with a special separator:

$$s=\tau(x)\in\mathcal{S},\qquad s=\text{input}\,\|\,\texttt{|||}\,\|\,\text{target}.$$

PromptSource further defines $\mathcal{P}_D:=\{\tau_1,\tau_2,\ldots\}$ as the set of all prompt templates for a dataset $D$, and notes that when $\tau$ contains nondeterminism, choice functions are seeded so that generation can be reproduced or exhaustively enumerated (Bach et al., 2022).

PromptSuite adopts a different but complementary formalization. It decomposes a prompt into four ordered components—Instruction, Prompt Format, Demonstrations, and Instance Content—and writes a prompt as

$$P=\bigl(p_{\mathrm{inst}},p_{\mathrm{fmt}},p_{\mathrm{demo}},p_{\mathrm{content}}\bigr)\in\mathcal{P}.$$

A perturbation $\mathcal{S}_{in}\times\mathcal{S}_{out}$0 acts on one component, and multi-component variation is expressed as

$\mathcal{S}_{in}\times\mathcal{S}_{out}$1

This makes prompt variation a first-class operation rather than an ad hoc editing process (Habba et al., 20 Jul 2025).

PromptChain shifts the ontology again by defining prompts as first-class digital assets. In that formulation, a prompt is a JSON document organized into content, metadata, provenance, validation, and usage fields, with on-chain indices for promptId, ipfsHash, creator, version, parentId, timestamp, stakedTokens, and validationScore. The prompt is therefore not only a string or template but also a versioned object with ownership, validation, and usage statistics (Bara, 13 Jul 2025).

In VICL, the prompt object is visual rather than textual. A prompt database $\mathcal{S}_{in}\times\mathcal{S}_{out}$2 contains image–mask or image–label pairs $\mathcal{S}_{in}\times\mathcal{S}_{out}$3, and a retriever selects the top-$\mathcal{S}_{in}\times\mathcal{S}_{out}$4 most similar prompts for a query image $\mathcal{S}_{in}\times\mathcal{S}_{out}$5. Here, prompthood is tied to demonstrational conditioning through pixels rather than through language. This suggests that the term “prompt” in PromptHub-related work is modality-general, even though the mechanisms of construction and use differ substantially (Luo et al., 19 Mar 2026).

2. PromptSource and the repository model

PromptSource is an integrated development environment and repository for natural-language prompts. It addresses what the paper describes as emergent challenges in prompt-based NLP with three components: a templating language for defining data-linked prompts, an interface for rapidly iterating on prompt development by observing outputs on many examples, and a community-driven set of guidelines for contributing prompts to a common pool. It is built as a thin GUI front end via Streamlit on top of the HuggingFace Datasets library, the Jinja2 templating engine, and a GitHub-backed repository, P3, for storing and versioning templates and metadata (Bach et al., 2022).

Its interface is organized into three complementary views. The Browse view supports inspection of a dataset’s README, metadata, and raw examples, and later enables side-by-side browsing of $\mathcal{S}_{in}\times\mathcal{S}_{out}$6 pairs with substitutions highlighted. The Sourcing view provides an editor panel for writing Jinja2 templates, live preview of the current example’s output, and fields for metadata such as template name, reference, valid outputs, original-task flag, and evaluation metrics. The Helicopter view acts as a dashboard of datasets and counts of existing prompts per dataset, guiding authors and reviewers toward under-templated datasets (Bach et al., 2022).

The templating language combines Jinja2 with a small library of prompt-oriented functions. It supports placeholders for dataset fields, conditional blocks, loops, a choice(...) function that either uses a seeded RNG or exhaustively enumerates options, and metadata for valid completions such as ["entailment","contradiction","neutral"]. Internally, each template is compiled by Jinja2 into a small AST and executed over examples. Because both input and target are required to read as fluent text, templates are constrained by a natural-language requirement rather than being arbitrary symbolic programs (Bach et al., 2022).

PromptSource also operationalizes prompt contribution as a community process. Contributors add or modify YAML template files under promptsource/templates/ and submit a pull request. Review checks whether $\mathcal{S}_{in}\times\mathcal{S}_{out}$7 covers all examples or gracefully skips them, whether prompts are unambiguous and high-quality, and whether metadata conforms to requirements. Required metadata fields include name, authors/reference, original_task, valid_outputs, input_contains_choices, and metrics. The guidelines further specify that datasets should receive 5–10 or more varied prompts to encourage robustness studies (Bach et al., 2022).

At the paper’s January 2022 cutoff, the Public Pool of Prompts contained 2,052 English prompts covering 170 English datasets and 269 subsets, with an average 7.6 prompts per subset and 5.6 prompts per subset that restate the original task. Over 50 unique contributors from 25 institutions across 10 countries participated in an open hackathon under the BigScience umbrella. The repository had already powered at least three major research projects: T0 multitask, multilingual prompting, and in-context learning studies (Bach et al., 2022).

PromptSource’s positioning clarifies what a PromptHub is not. Annotation platforms such as GATE and WebAnno focus on discrete labels or spans rather than generative mappings, while automatic-prompting systems such as AutoPrompt and soft-prompt tuning generate prompts or embeddings via gradient search but do not provide a human-centric repository. PromptSource’s combination of human-readable templates, dataset-linked functions, and integrated GUI plus GitHub governance therefore defines a repository-centered PromptHub model (Bach et al., 2022).

3. PromptSuite and modular multi-prompt evaluation

PromptSuite generalizes the hub idea from storage and authoring to automatic multi-prompt generation. It is organized into an Ingestion Layer, Template Manager, Perturbation Engine, Execution and Export modules, and user interfaces exposed both as a Python API and a Streamlit-based web UI. The Ingestion Layer supports HuggingFace datasets, CSV/JSON, and pandas.DataFrame inputs, while the Schema Verifier ensures that placeholders in templates match dataset fields. The Template Manager maintains a Component Registry for instruction, prompt format, demonstrations, and instance content, and the Perturbation Engine provides core plugins, a registry, and a Variation Combinator that controls Cartesian-product versus random sampling of perturbation combinations (Habba et al., 20 Jul 2025).

Its methodological contribution is modular prompt design. Each component can be perturbed through a plugin interface, with perturbation families including lexical paraphrase, syntactic context addition, formatting changes, and demonstration editing. The system generates up to $\mathcal{S}_{in}\times\mathcal{S}_{out}$8 variations per component and then either takes the Cartesian product or samples combinations to keep the total manageable. This gives PromptSuite a task-agnostic mechanism for controlled prompt variation rather than one-off manual rewriting (Habba et al., 20 Jul 2025).

The API makes this structure explicit. The PromptSuite class exposes methods to load datasets, set templates, configure variations_per_field, choose sampling as 'cartesian' or 'random', specify an api_platform, and call generate() and export(). The web interface mirrors the same workflow: upload or select a dataset, define the template and perturbation types per component, preview generated variations with highlighted diffs, and download a multi-prompt dataset or call the backend from a script (Habba et al., 20 Jul 2025).

The framework is motivated by the claim that evaluating LLMs with a single prompt has proven unreliable. In case studies on nine benchmarks spanning classification, question answering, translation, summarization, reasoning, and code generation, two representative LLMs—GPT-4o-mini and Llama-3.3-70B—were evaluated with 50 instances per task and up to 25 variations per instance, yielding approximately 1,250 prompts per task. Reported metrics were accuracy for classification and Q&A, ROUGE-L for summarization, BLEU for translation, and pass@1/5 for code; temperature was set to 0 except for code tasks, where $\mathcal{S}_{in}\times\mathcal{S}_{out}$9 (Habba et al., 20 Jul 2025).

The reported spreads are substantial. GPT-4o-mini on GPQA-Diamond ranged from 20% to 50% accuracy, a $\tau$0 percentage-point difference. On selected tasks, SQuAD exact match for Llama-3.3-70B ranged from 0.55 to 0.78; CNN/DailyMail ROUGE-L for GPT-4o-mini ranged from 0.35 to 0.42; WMT14 English-to-Russian BLEU for Llama-3.3-70B ranged from 27.1 to 29.8; and HumanEval pass@1 for GPT-4o-mini ranged from 0.54 to 0.68. Component ablations showed that demonstration editing most affects math reasoning, whereas formatting strongly affects reading comprehension tasks (Habba et al., 20 Jul 2025).

As a PromptHub model, PromptSuite centralizes design, generation, evaluation, and governance. Its best practices for production deployment—template registries in source control, variation budgeting, caching LLM calls, monitoring dashboards, and CI integration—indicate a shift from prompt collection toward prompt lifecycle management (Habba et al., 20 Jul 2025).

4. Prompt recommendation and interactive use

PromptHelper introduces a distinct PromptHub function: prompt recommendation during ongoing interaction. It is a prompt recommender system layered on top of a standard chat-based writing bot, “WritingBot,” implemented on gpt-5.1. After receiving a model response, the user can click a PromptHelper icon, opening a side panel that displays 5–7 follow-up prompt suggestions. Internally, the system assembles a recommendation request from the user’s last prompt, the model’s most recent reply, and a structured instruction template, sends that request to gpt-5.1, and presents de-duplicated outputs directly to the user without additional server-side ranking or machine learning (Kim et al., 22 Jan 2026).

Candidate generation is category-guided. The same LLM produces suggestions spanning predefined categories such as “Brainstorming and Ideation,” “Editing and Revision,” and “Explanation and Summarization,” and each item follows a five-field schema {task, category, context, title, prompt}. The interface renders each suggestion as a concise card with a title, a category badge, and the full follow-up prompt text. Users can copy a card into the chat input box, optionally edit it, and submit it for the next turn; the panel remains open for further browsing (Kim et al., 22 Jan 2026).

The evaluation used a $\tau$1 fully within-subjects design with factors Writing Task (Creative versus Academic) and System State (PromptHelper ON versus OFF). Thirty-two participants completed all four conditions in 10-minute blocks under Latin-square counterbalancing. Measures included Creativity Support Index composites for Exploration, Expressiveness, and Results-Worth-Effort, NASA-TLX subscales for workload, and post-task usability ratings. Repeated-measures ANOVA tested main effects of System and Task and their interaction (Kim et al., 22 Jan 2026).

Quantitatively, PromptHelper significantly increased perceived exploration and expressiveness without increasing cognitive workload. Exploration showed a main effect of PromptHelper, $\tau$2, $\tau$3, $\tau$4; paired tests were significant for both Academic ON versus OFF, $\tau$5, $\tau$6, $\tau$7, and Creative ON versus OFF, $\tau$8, $\tau$9, $$\tau:\mathcal{X}\to\mathcal{S}_{in}\times\mathcal{S}_{out}.$$0. Expressiveness also showed a main effect, $$\tau:\mathcal{X}\to\mathcal{S}_{in}\times\mathcal{S}_{out}.$$1, $$\tau:\mathcal{X}\to\mathcal{S}_{in}\times\mathcal{S}_{out}.$$2, $$\tau:\mathcal{X}\to\mathcal{S}_{in}\times\mathcal{S}_{out}.$$3, significant for the Academic task, $$\tau:\mathcal{X}\to\mathcal{S}_{in}\times\mathcal{S}_{out}.$$4, $$\tau:\mathcal{X}\to\mathcal{S}_{in}\times\mathcal{S}_{out}.$$5, $$\tau:\mathcal{X}\to\mathcal{S}_{in}\times\mathcal{S}_{out}.$$6, but not for the Creative task, $$\tau:\mathcal{X}\to\mathcal{S}_{in}\times\mathcal{S}_{out}.$$7, $$\tau:\mathcal{X}\to\mathcal{S}_{in}\times\mathcal{S}_{out}.$$8. No significant changes were observed in overall usability or mental workload (Kim et al., 22 Jan 2026).

Qualitative themes were “Branching into new directions,” “Clarifying intent,” and “Shifted effort.” Participants reported using recommendations to overcome uncertainty about what to ask next and to reallocate effort from inventing prompts de novo toward evaluating and refining suggestions. For a PromptHub conception, this introduces a human-in-the-loop layer in which prompts are not merely authored or stored but surfaced contextually to scaffold exploratory interaction while preserving user agency (Kim et al., 22 Jan 2026).

5. Decentralized PromptHub: provenance, validation, and incentives

PromptChain proposes a decentralized Web3 architecture that treats AI prompts as first-class digital assets with verifiable ownership, version control, and monetization capabilities. Its four-layer design comprises a Storage Layer based on IPFS, a Blockchain Layer on Ethereum or Layer 2, an Application Layer with REST and GraphQL endpoints backed by The Graph subgraphs, and an Integration Layer with connectors to OpenAI, Anthropic, HuggingFace, or local hosts. Full prompt content and rich metadata JSON are stored off-chain in IPFS and addressed by CIDs, while essential indices are stored on-chain in smart contracts (Bara, 13 Jul 2025).

The blockchain layer is divided among four contracts or modules. PromptRegistry records promptId→Prompt mappings with fields including creator, ipfsHash, version, timestamp, validationScore, stake, and parentId. ValidationGovernance manages validator staking, slashing, and weighted vote aggregation. IncentivePool accumulates fees and distributes rewards to creators, validators, and curators. GovernanceModule manages parameter updates such as MIN_STAKE and reward coefficients through proposal creation, on-chain voting weighted by reputation, and execution via a multisig or diamond proxy upgrade pattern (Bara, 13 Jul 2025).

Version control is implemented through a coupling of IPFS ancestry and on-chain registration. Every new prompt or derivative first produces a new CID through IPFS add and then triggers registerPrompt(ipfsHash, parentId). The contract computes

$$\tau:\mathcal{X}\to\mathcal{S}_{in}\times\mathcal{S}_{out}.$$9

sets version = parentId==0 ? 1 : parent.version+1, stores parentPromptId, and emits PromptRegistered. Because the CID’s Merkle-DAG encodes parent linkage, the on-chain parent pointer mirrors IPFS ancestry, producing what the paper calls a tamper-resistant provenance trail (Bara, 13 Jul 2025).

Validation is stake-weighted. If validator $s\in\mathcal{S}$0 stakes $s\in\mathcal{S}$1 tokens, the normalized weight is

$s\in\mathcal{S}$2

A prompt achieves consensus when the cumulative weight of validators passing it meets threshold $s\in\mathcal{S}$3:

$s\in\mathcal{S}$4

Domain experts with higher on-chain reputation may multiply their stake-weight by an expertise factor $s\in\mathcal{S}$5, and invalid or outlier votes lose part of their stake through slashing (Bara, 13 Jul 2025).

The incentive design introduces a token economy around prompt creation and curation. PromptChain’s utility/governance token, PCT, is minted at genesis with a fixed supply, with an example allocation of 20% to ecosystem grants, 10% to the team with four-year vesting, 5% to advisors, and 65% reserved for on-chain rewards. Creator, validator, and curator rewards are computed from quality, usage, derivatives, validation accuracy, expertise, and collection measures, with coefficients adjusted dynamically through DAO proposals (Bara, 13 Jul 2025).

PromptChain also reports performance comparisons. Registering a prompt costs approximately 0.50 USD on Ethereum mainnet and approximately 0.01 USD on Arbitrum. Native Ethereum handles approximately 15 TPS, while Layer 2 solutions enable more than 1,000 TPS for prompt registrations and validations. End-to-end prompt reads complete in 200–400 ms through sub-second IPFS retrieval and Graph-indexed queries, compared with 150–250 ms for centralized APIs when network overhead is included. A plausible implication is that PromptHub infrastructures can be designed around either centralized governance or blockchain-anchored provenance, with different trade-offs in ownership guarantees, censorship resistance, and operational complexity (Bara, 13 Jul 2025).

6. PromptHub in Visual In-Context Learning

The paper “PromptHub” defines the term in a narrower but technically elaborate sense: a plug-in framework for improving multi-prompt Visual In-Context Learning through locality-aware fusion, concentration, and alignment. VICL assumes a prompt database $s\in\mathcal{S}$6 of image–mask or image–label pairs $s\in\mathcal{S}$7 and a retriever $s\in\mathcal{S}$8 that selects the top-$s\in\mathcal{S}$9 most similar prompts for a query image $$s=\tau(x)\in\mathcal{S},\qquad s=\text{input}\,\|\,\texttt{|||}\,\|\,\text{target}.$$0. In single-prompt VICL, the selected prompt pair and query form a canvas

$$s=\tau(x)\in\mathcal{S},\qquad s=\text{input}\,\|\,\texttt{|||}\,\|\,\text{target}.$$1

which is processed by a frozen MAE-VQGAN backbone to inpaint the mask and predict the label (Luo et al., 19 Mar 2026).

PromptHub inserts a small, trainable fusion module before the frozen backbone. Given the query image and $$s=\tau(x)\in\mathcal{S},\qquad s=\text{input}\,\|\,\texttt{|||}\,\|\,\text{target}.$$2 prompt pairs, it outputs fused feature maps $$s=\tau(x)\in\mathcal{S},\qquad s=\text{input}\,\|\,\texttt{|||}\,\|\,\text{target}.$$3 and $$s=\tau(x)\in\mathcal{S},\qquad s=\text{input}\,\|\,\texttt{|||}\,\|\,\text{target}.$$4 that replace the prompt portion of the canvas:

$$s=\tau(x)\in\mathcal{S},\qquad s=\text{input}\,\|\,\texttt{|||}\,\|\,\text{target}.$$5

Its key innovation is locality-aware fusion. For each query patch at position $$s=\tau(x)\in\mathcal{S},\qquad s=\text{input}\,\|\,\texttt{|||}\,\|\,\text{target}.$$6, a locality prior $$s=\tau(x)\in\mathcal{S},\qquad s=\text{input}\,\|\,\texttt{|||}\,\|\,\text{target}.$$7 assigns a spatial weight over the feature grid, using either a Gaussian or Laplacian form. Cross-attention then applies this prior to bias attention toward nearby prompt patches while retaining a global receptive field (Luo et al., 19 Mar 2026).

Training is governed by what the paper calls a “Fusion–Utilization–Prediction” loop. The backbone remains frozen and only the fusion parameters $$s=\tau(x)\in\mathcal{S},\qquad s=\text{input}\,\|\,\texttt{|||}\,\|\,\text{target}.$$8 are trained. Prediction loss $$s=\tau(x)\in\mathcal{S},\qquad s=\text{input}\,\|\,\texttt{|||}\,\|\,\text{target}.$$9 preserves native in-painting behavior, alignment loss $\mathcal{P}_D:=\{\tau_1,\tau_2,\ldots\}$0 makes the fused prompt pair behave like the true query prompt pair, and utilization loss $\mathcal{P}_D:=\{\tau_1,\tau_2,\ldots\}$1 reduces the feature-space gap between fused prompts and the query pair so that the backbone trusts the fused cues. The joint objective is

$\mathcal{P}_D:=\{\tau_1,\tau_2,\ldots\}$2

During training, VICL-oriented data augmentation randomly replaces each retrieved prompt either with the query pair with probability $\mathcal{P}_D:=\{\tau_1,\tau_2,\ldots\}$3 or with a randomly sampled prompt with probability $\mathcal{P}_D:=\{\tau_1,\tau_2,\ldots\}$4; default values are 0.1 each (Luo et al., 19 Mar 2026).

Experiments use a frozen MAE-VQGAN backbone with patch size 16 and a pixel-level retriever, “Prompt-SelF,” on three tasks: foreground segmentation on Pascal-5$\mathcal{P}_D:=\{\tau_1,\tau_2,\ldots\}$5 measured by mean IoU, single-object detection on Pascal VOC 2012 measured by mean IoU, and image colorization on ImageNet-1K measured by RGB-space MSE. Baselines include Random retrieval, UnsupPR, Prompt-SelF, SupPR, Partial2Global, InMeMo, VTV, and Condenser with $\mathcal{P}_D:=\{\tau_1,\tau_2,\ldots\}$6 or $\mathcal{P}_D:=\{\tau_1,\tau_2,\ldots\}$7 (Luo et al., 19 Mar 2026).

Quantitative results show that PromptHub beats Condenser in both single-prompt and multi-prompt configurations. For $\mathcal{P}_D:=\{\tau_1,\tau_2,\ldots\}$8, gains are +2.3% mIoU for segmentation, +3.0% for detection, and +5.1% MSE reduction for colorization. For $\mathcal{P}_D:=\{\tau_1,\tau_2,\ldots\}$9, gains are +2.5% for segmentation, +2.1% for detection, and +7.2% for colorization. In transfer from COCO-5$D$0 to Pascal-5$D$1, PromptHub$D$2 exceeds Condenser$D$3 by +1.65% mean mIoU. Under horizontal flips of query prompts, PromptHub$D$4 drops by only –0.66% mIoU versus –1.39% for Condenser$D$5. Ablations show that removing $D$6 destroys performance, dropping to approximately 9% mIoU; removing $D$7 or $D$8 costs approximately 1%–1.5% mIoU each; replacing the locality prior with global fusion or convolution-only fusion degrades performance by 2%–3%; and disabling data augmentation costs approximately 0.7% mIoU (Luo et al., 19 Mar 2026).

This visual PromptHub is conceptually distinct from textual prompt repositories and recommender systems. It does not manage prompt strings, metadata, or natural-language interfaces; instead, it operationalizes “hubness” as multi-prompt fusion over retrieved demonstrations. The commonality lies in the central role of multiple prompts, controlled combination, and mechanisms for improving robustness (Luo et al., 19 Mar 2026).

7. Limits, distinctions, and likely trajectories

Several limitations recur across PromptHub formulations. PromptSource notes that Jinja2 logic can become complex for elaborate tasks, lacks real-time collaborative editing because a single user runs local Streamlit, and offers no built-in analytics dashboard for prompt performance across models. It identifies multilingual and code-switched prompts, few-shot priming integrations, collaborative real-time editing, built-in analytics dashboards, model-in-the-loop testing, and automatic prompt augmentation as natural extensions (Bach et al., 2022).

PromptSuite frames the central problem differently: the challenge is not prompt authoring alone but the combinatorial burden of generating and evaluating prompt variants robustly. Its architecture responds with controlled perturbations, caching, exporters, and CI-oriented workflows. PromptHelper highlights another limit: many users struggle to explore alternative directions or articulate intent, suggesting that prompt hubs may need recommendation and personalization layers rather than only repositories. Its released code and dataset explicitly invite community experimentation with embedding-based relevance and diversity optimization, and the paper discusses tracking accepted, modified, or rejected prompts to learn user preferences over time (Habba et al., 20 Jul 2025, Kim et al., 22 Jan 2026).

PromptChain identifies attribution, quality assurance, and fair compensation as limitations of centralized platforms and responds with immutable storage, stake-weighted validation, and token incentives. PromptHub in VICL identifies a different bottleneck: patch-wise fusion and model-agnostic supervision can hinder exploitation of informative cues, motivating locality-aware fusion, complementary objectives, and data augmentation (Bara, 13 Jul 2025, Luo et al., 19 Mar 2026).

A common misconception would be to treat PromptHub as the name of one settled architecture. The literature instead uses the term across at least five technical agendas: natural-language template repositories, modular multi-prompt generation frameworks, decentralized prompt asset registries, prompt recommender systems, and locality-aware visual prompt fusion. Taken together, these works indicate that PromptHub has become a unifying label for infrastructures in which prompts are no longer incidental strings but managed, evaluated, and governed artifacts whose behavior materially affects model performance and human interaction (Bach et al., 2022, Habba et al., 20 Jul 2025, Bara, 13 Jul 2025, Kim et al., 22 Jan 2026, Luo et al., 19 Mar 2026).