Control Plain presents a case study focused on solving one of the most persistent challenges in LLMOps: making AI agents reliable enough for production deployment. The company identifies a fundamental problem that affects 95% of GenAI pilots - while building AI agents for demonstrations is relatively straightforward, deploying them reliably in production environments remains extremely difficult due to unpredictable behavior across diverse real-world inputs. The core challenge emerges from the vast input space that production AI agents must handle. Control Plain illustrates this with a customer support scenario where an agent might work well with simple requests like "Can you cancel order A1B2C3?" during development, but struggle with complex real-world queries such as "Cancel every item in my order last week that's not related to video gaming, and split the refund between my credit card and paypal account." This complexity mismatch between development and production environments leads to unreliable agent behavior. Control Plain's technical approach centers on what they term "intentional prompt injection" - a dynamic prompting technique designed to address reliability issues without creating unwieldy system prompts. Traditional approaches to improving agent reliability typically involve continuously expanding system prompts with rules, conditions, and exceptions for edge cases. This process creates what the company calls "franken-prompts" - bloated, brittle prompts that become increasingly difficult to maintain and can confuse both humans and LLMs. The resulting "prompt debt" mirrors technical debt in software development, making systems harder to update and debug over time. Their solution involves creating a structured database of key-value pairs where keys represent textual triggers in user responses, and values contain specific instructions the agent must follow. At runtime, the system performs semantic matching between the user's message and the stored queries. When a match is found above a similarity threshold, the corresponding rule is dynamically injected directly into the user message content before processing by the LLM. This takes advantage of the model's recency bias, effectively priming it to focus on the most relevant policy rules when responding. The company demonstrates this technique using a practical example from τ-bench, specifically an airline customer support agent tasked with helping customers update flight reservations. In their baseline testing, the agent failed to update passenger information approximately 20% of the time, despite having explicit rules in the system prompt about passenger modifications. Traditional approaches of tweaking language, adding emphasis through capitalization, or including modifiers like "CRITICAL" and "IMPORTANT" proved ineffective. By implementing their dynamic prompt injection system, they created specific query-rule mappings. For instance, when a user message contains "I want to change the passenger to myself," the system automatically injects a detailed rule: "[IMPORTANT] Per the policy, the user is allowed to change the passenger name and details for a reservation. But they cannot change the passenger count. The user can change the passenger name and details without an escalation to a human agent." This augmented message provides immediate, contextually relevant guidance to the LLM. Control Plain's experimental methodology, while acknowledged as not scientifically rigorous, provides meaningful insights into the technique's effectiveness. They tested their approach using τ-bench scenarios, employing GPT-5 for the AI agent and Claude 4 Sonnet for user simulation. Their results show dramatic improvements in reliability - scenarios that previously achieved 80% success rates reached 100% success rates with prompt injection enabled. Importantly, for scenarios unrelated to passenger modifications, the baseline performance remained unchanged, suggesting the technique doesn't negatively impact general agent capabilities. The semantic similarity matching component of their system uses carefully tuned thresholds to ensure prompts are only injected when user messages closely match stored queries. Interestingly, they found that even when prompt injection fired for unrelated messages, the extra instructions didn't harm performance, suggesting the approach has built-in robustness. Control Plain also evaluated alternative approaches like few-shot prompting, where examples are inserted into system prompts. They found this approach less effective for their use cases, particularly when conversational sessions diverged from provided examples. Few-shot examples also significantly increased input token counts without providing generalizable solutions, making them economically inefficient for production deployment. The broader implications of this work extend beyond the specific technical implementation. Control Plain positions their approach as part of a larger trend toward dynamic prompt engineering techniques that can adapt to context rather than relying on static, monolithic prompts. This aligns with emerging design principles like the "12-factor agents" methodology, which emphasizes modular, maintainable agent architectures. From an LLMOps perspective, this case study highlights several critical production considerations. First, it demonstrates the importance of comprehensive testing across diverse input scenarios that mirror real-world usage rather than simplified development cases. Second, it shows how traditional prompt optimization approaches can create maintenance burdens that compound over time. Third, it illustrates the value of architectures that separate core system logic from context-specific rules, enabling more sustainable scaling. The technique also raises important questions about prompt engineering as a discipline within LLMOps. Control Plain's approach suggests that the future of production LLM systems may involve sophisticated prompt management systems that can dynamically adapt instructions based on context, user intent, and business rules. This represents a shift from viewing prompts as static configuration toward treating them as dynamic, data-driven components of the system. However, the case study also presents some limitations that practitioners should consider. The evaluation methodology, while showing promising results, is limited in scope and relies on a specific benchmark that may not generalize to all domains. The semantic matching component introduces additional complexity and potential failure modes that need to be monitored and maintained. Furthermore, the approach requires careful curation of query-rule pairs, which could become a bottleneck as systems scale to handle more diverse scenarios. The economic implications of this approach are also worth considering. While dynamic prompt injection may reduce the need for extensive prompt debugging and maintenance, it introduces new operational overhead in managing the query-rule database and semantic matching systems. Organizations implementing this approach would need to balance these trade-offs against the improved reliability and maintainability benefits. Control Plain's work contributes to the growing body of knowledge around making LLM-based systems production-ready. Their focus on reliability, maintainability, and scalability addresses real pain points that many organizations face when moving from AI demonstrations to production deployments. The technique represents a practical approach to managing the complexity inherent in real-world AI agent applications while avoiding some of the pitfalls of traditional prompt engineering approaches.