Hello everyone. I am RA principal, Salesforce engineer and platform architect at ON 24. I'm excited to be speaking at Con 42 Prompt in day 2025. It's a space where we explore how to make AI systems more reliable and human aligned. My talk today is titled Prompting for Trust. It's about how we as builders can design prompts that make large language morals not just accurate, but trustworthy. In enterprise AI trust is the real adoption barrier, and it starts long before deployment. Here's what we'll walk through today. First we'll look at the trust challenge in enter enterprise ai. Then we will talk about why trust starts right at the prompt. We will move into five core principles for trust building prompts, some real world case studies, and we'll finish with the roadmap and key takeaways that can apply in own ecosystems. The trust challenge in enterprise ai. In many organizations, LMS are already running chatbots, co-pilots, and decision supporting tools, but performance alone doesn't create adoption if users can't explain how or why an LLM reached its answer. They won't act on it. That's the trust gap. An invisible friction that slows AI rollout. You'll see systems technically capable but unused because people don't feel confident in their reasoning. So the challenge isn't about model capability, it's about human confidence. Trust begins at the prompt layer. That's why we instruct the model, determine the way we instruct. The model determines how it behaves. Three areas matter most. Prompt design where we control how the model frames its answers, sites information and expresses uncertainty, context, scaffolding where we give structured content. So outputs used enterprise language, and comply with regulations and output performing where we make reasoning visible and easy to validate downstream. So prompt engineering isn't about better responses. It's about designing comprehension, accountability, and alignment into every interaction, core principles of trust building prompts. Now let's talk about the five principles that make prompts trustworthy. Confidence tagging, ask the model to label outputs. As act now needs review and seek expert input. Source of attribution, make the model side documents or reasoning sources directly. Adaptive clarification. Let the model ask for more information when the user's intent is unclear. Progressive disclosure show high level insights first and then deeper details only when requested. Audit trail integration embed metadata into outputs so every decision can be placed and audited later. Together. These principles make the system transparent, accountable, and easier to trust confidence. Drug tagging in action. Here's what it looks like in practice. Instead of just outputting data, the model says defect rate, moderate coined action, inspect the proportion of the batch. Now the user instantly understands the level of certainty and the next step. It's no longer an answer. It's guided contextual response. Conference tagging gives users permission to act or to validate further with clarity lining outputs with enterprise context. One major reason why trust breakstone is context mismatch. Gmic elements don't understand your organization's vocabulary, regulatory boundaries or thresholds. So the solution is structured. We inject domain vocabulary like. Qualified or material risk. We embed regulatory S like GDPR or SOC compliant requirements, and then we define thresholds. Specifying, specifying where to escalate, approve, or send for human. This ensures that model outputs are consistent with enterprise policies and human judgment building. Building feedback loops into prompts. Trust isn't something you design once. It's something you maintain. That's why Facebook feedback loops are critical. When users correct an error response, that signal can be captured right into that chat or orchestration layer. Then we refine prompts, identify failure models, and then we fine tune models based on real feedback. A trustworthy system doesn't just doesn't just answer it like, here's a case study lead qualification assistant. Here's a real example. Sales reps are ignoring AI generated lead scores. The issue wasn't accuracy, it was explanation. So we redesigned the prompts to incur confidence tags. Source citations and structuring the reasoning change. The result is 71% more follow up actions and 34% improvement in conversations. Nothing changed in the model. Only the prompts. That's the power of trust centered design. One more case study summarization pipeline. It's a legal documentation summary. Teams refuse to trust AI Aries without every clause. We updated prompts to add section level attribution and highly. Ambiguous losses or deviations with standard templates. Suddenly the review time dropped drastically and the user conference rose near 90%. Once people could see where each statement came from, trust followed naturally. This is one more yesterday, decision support chat bot. When asked, should we approve this vendor contract? The older version answered immediately. The improved version asked, is this a new vendor or a renewal? What's the contract value when it checks? Spend thresholds and compliance before recommending approval? That small shift gathering, missing context first dramatically increased user reliability and trust. Structured prompting techniques to make this scalable. We used structured prompting patterns. Schema driven outputs force the model to respond in JSON or it, so systems can validate automatically, chain automatically. Chain of thought prompting makes the models show its reasoning before giving the final. And conditional instructions handle edge cases. For example, if data is missing, it'll ask for clarification. These design patterns create transparency by default. This slide shows the transformation clearly before black box outputs. No, no visibility. No confidence signals. Low user engagement After transparent designing chains, source attribution, confidence tagging, and context awareness. When you treat prompt layer. As a design service, not a technical input, you turn alarms from opaque responders into trusted collaborators. Now looking at the implementation roadmap, here's how to get started in your own environment. Step one or current prompts, find where ambiguity or opacity creates trust gaps. Redesign for transparency, add tags and verification triggers. Test with real users, validate comp comprehension and usability. And I trade based on feedback. Keep refining instructions to close landing lobes. Trust is not a feature, it's a continuous process. So the key takeaways, trust is designed, you can architect. Transparency, accountability and alignment through intentional prompt design context is critical. Structured prompting users. Reflect your enterprise vocabulary and policies. Feedback drives improvement the most trusted systems evolve with user input. And finally, users trust what they understand. When we combine confidence tagging, attribution, and progressive disclosure, your AI stocks being a mystery, becomes a reliable partner. Thank you for your time and attention to this Con 42 prompting 3 20 25. I'm Raku and I hope these ideas help you design prompt strategies that earn trust, not just s Feel free to connect and continue the discussion on building transparent, human aligned element systems. Thank you very much.