This prompt is designed for knowledge workers, compliance officers, and communications leads who must distribute AI-generated meeting summaries without exposing confidential statements, off-record remarks, or restricted context. The primary job-to-be-done is to act as a first-pass sanitization layer: the model receives a raw transcript or detailed summary and returns a version where protected content is identified and redacted, while decisions, action items, and non-sensitive context are preserved. The ideal user operates in an environment where meeting notes move from a secure internal system to a broader distribution list—such as board observers, client stakeholders, or cross-departmental teams—and needs a repeatable, auditable filter before human review.
Prompt
Confidential Meeting Summary Sanitization Prompt

When to Use This Prompt
Defines the job-to-be-done, ideal user, and operational boundaries for the confidential meeting summary sanitization prompt.
Use this prompt when the raw material contains a mix of public-ready and confidential discussion, and the cost of manual redaction across many meetings is prohibitive. It is appropriate for recurring operational meetings, project stand-ups, vendor calls, and internal reviews where sensitive asides, personnel matters, unreleased financial figures, legal strategy, or trade secret details may appear alongside routine updates. The prompt is not a replacement for legal review, formal classification, or data loss prevention (DLP) systems. Do not use it for meetings where the entire discussion is classified, where regulatory filing obligations apply to the raw transcript, or where redaction failure would create mandatory breach notification requirements. In those high-stakes scenarios, this prompt may serve as a pre-processing step, but a qualified human reviewer must always sign off on the final output.
Before deploying this prompt, ensure you have a clear definition of what constitutes 'confidential' in your organization. The prompt template includes a [CONFIDENTIALITY_POLICY] placeholder where you must supply concrete categories—such as 'unreleased financial data,' 'personnel performance discussions,' 'attorney-client privileged communication,' or 'trade secret technical specifications.' Vague policies produce inconsistent redaction. You should also prepare a set of evaluation examples that test both over-redaction (where the model removes information that was safe to share, destroying the summary's utility) and under-redaction (where sensitive content slips through). After the model returns a sanitized summary, route the output to a human reviewer and log the original, the redacted version, and the reviewer's changes. This audit trail is essential for demonstrating due diligence if a disclosure incident occurs.
Use Case Fit
Where the Confidential Meeting Summary Sanitization Prompt works and where it introduces unacceptable risk. Use these cards to decide whether this prompt fits your workflow before you invest in eval design.
Strong Fit: Internal Recurring Meetings
Use when: you have weekly standups, project syncs, or team retrospectives where most content is shareable but occasional personnel issues, budget numbers, or strategic asides need redaction. Avoid when: the entire meeting is classified or attorney-client privileged—this prompt is a sanitizer, not a declassification engine.
Required Inputs: Transcript + Confidentiality Markers
What to watch: the prompt needs a verbatim transcript and explicit markers for off-record segments, closed-door portions, or speaker-flagged confidential remarks. Guardrail: if your meeting recording lacks structured markers, run a pre-classification step to tag sensitive segments before sanitization—bare transcripts produce unreliable redactions.
Poor Fit: Single-Pass Regulatory Compliance
Risk: teams treating this prompt as a compliance automation step for GDPR, HIPAA, or SOX without human review. Guardrail: this prompt reduces leakage risk but does not guarantee it. Always route sanitized outputs through a human reviewer or a secondary verification prompt before distribution to external parties or regulated stakeholders.
Operational Risk: Over-Redaction Destroys Actionability
What to watch: aggressive sanitization that strips names, numbers, and context can leave a summary so vague that action items become meaningless. Guardrail: define a minimum viable information threshold in your eval criteria—if the sanitized output lacks assignable owners or measurable deadlines, flag it for human reconstruction rather than distributing an empty shell.
Operational Risk: Under-Redaction from Implicit References
What to watch: the model removes explicit names but retains contextual clues (role, project, recent event) that allow re-identification. Guardrail: include adversarial eval cases where the transcript contains indirect identifiers—team size of one, unique project milestones, or recent promotion context—and verify the sanitized output does not enable inference attacks.
Variant Need: Multi-Language Meeting Transcripts
Avoid when: your meeting transcripts mix languages, contain code-switching, or use domain jargon that the base prompt was not calibrated for. Guardrail: if multilingual meetings are common, create a language-detection pre-pass and maintain locale-specific sanitization examples in your few-shot set—confidentiality boundaries do not translate cleanly across languages without adaptation.
Copy-Ready Prompt Template
A copy-ready system prompt for sanitizing confidential meeting transcripts before distribution.
This prompt template is designed to be pasted directly into your system instructions or used as a user message. It instructs the model to act as a confidentiality filter, identifying and redacting sensitive information from meeting transcripts while preserving the actionable substance. The template uses square-bracket placeholders that you must replace with your specific inputs before use. The core logic separates the task into two phases: first, a strict identification of confidential material based on your provided rules, and second, a rewriting step that produces a safe-for-distribution summary.
markdownYou are a Confidential Meeting Summary Sanitizer. Your task is to process a raw meeting transcript and produce a sanitized summary safe for distribution to [TARGET_AUDIENCE]. You must strictly follow a two-phase process. **Phase 1: Identification** Analyze the [RAW_TRANSCRIPT] and identify all text segments that match the following confidentiality rules. Do not output anything in this phase. - **Off-Record Remarks:** Statements explicitly marked as "off the record" or similar. - **Restricted Context:** Discussion of [RESTRICTED_TOPICS], including specific project names like [PROJECT_CODEWORDS]. - **Personal Data:** Any Personally Identifiable Information (PII) such as names, emails, or phone numbers not belonging to [ALLOWED_SPEAKERS]. - **Speculation:** Forward-looking financial or strategic speculation, including phrases like [SPECULATION_INDICATORS]. **Phase 2: Sanitization and Summary** Generate a concise meeting summary containing only the following allowed elements: - **Decisions Made:** Concrete decisions and their owners. - **Action Items:** Tasks assigned, to whom, and deadlines. - **General Status:** High-level, non-sensitive status updates. **Critical Rules for Sanitization:** 1. **Redact, Don't Rewrite:** Replace identified confidential segments with a `[REDACTED: <category>]` placeholder. Do not paraphrase or generalize the confidential information. 2. **Preserve Action:** If an action item is directly tied to a redacted topic, include the action but describe it generically, e.g., "[ACTION OWNER] to follow up on a restricted topic by [DATE]." 3. **No Source Attribution:** Do not attribute any statement to a specific speaker unless they are in the [ALLOWED_SPEAKERS] list. 4. **Empty Summary:** If the entire transcript is confidential, output only: "No distributable content found." **Output Format:** Output only the sanitized summary in plain text. Do not include any preamble or meta-commentary.
To adapt this template, start by defining the [TARGET_AUDIENCE] precisely, as this determines the acceptable level of abstraction. For example, a summary for a company-wide update will be far more generic than one for a project team with clearance. Next, populate the [RESTRICTED_TOPICS] and [PROJECT_CODEWORDS] lists from your data classification policy. The [SPECULATION_INDICATORS] list should include phrases like "I think we might acquire" or "the stock will jump if." Before deploying, you must test this prompt with transcripts containing edge cases, such as action items that are themselves confidential or meetings where a single off-record remark invalidates a subsequent decision. The final step is to run the output through a validation check to ensure no [REDACTED] placeholder contains the original sensitive text and that the summary remains coherent.
Prompt Variables
Required inputs for the Confidential Meeting Summary Sanitization Prompt. Each variable must be populated before the prompt is assembled and sent to the model. Missing or malformed inputs are the most common cause of sanitization failures in production.
| Placeholder | Purpose | Example | Validation Notes |
|---|---|---|---|
[RAW_TRANSCRIPT] | The full, unredacted meeting transcript to be sanitized | Alice: We need to close the Beta deal by Friday. Bob: Off the record, our runway is only 6 weeks. | Must be a non-empty string. Check for minimum 50 characters to avoid empty-transcript bypass. Null or whitespace-only input must be rejected before prompt assembly. |
[CONFIDENTIALITY_TIERS] | Ordered list of confidentiality tiers with definitions and handling rules | Tier 1 (Public): Safe for external distribution. Tier 2 (Internal): Within company only. Tier 3 (Confidential): Named recipients only. Tier 4 (Restricted): Legal counsel only. | Must be a valid JSON array of objects with 'tier', 'label', 'definition', and 'handling_rule' fields. Schema validation required. Empty array means no sanitization is possible and must abort. |
[REDACTION_PATTERNS] | Regex patterns or keyword lists that trigger automatic redaction | ['off the record', 'between us', 'not for distribution', 'pre-decision', 'attorney-client'] | Must be a valid JSON array of strings. Each pattern is case-insensitive by default. Null allowed if only tier-based classification is used. Validate that patterns compile without error before prompt injection. |
[OUTPUT_SCHEMA] | Strict JSON schema the sanitized output must conform to | { 'summary': string, 'action_items': array, 'redacted_segments': array, 'tier_assigned': string } | Must be a valid JSON Schema object. Required fields must include 'summary' and 'redacted_segments'. Reject schemas that allow the model to omit the redaction log. Validate with a JSON Schema validator before prompt assembly. |
[DISTRIBUTION_CONTEXT] | Who will receive the sanitized summary and under what constraints | { 'audience': 'all-hands', 'max_tier_allowed': 2, 'recipient_domains': ['company.com'] } | Must be a valid JSON object with 'audience' and 'max_tier_allowed' fields. If 'max_tier_allowed' is missing, default to Tier 1 to prevent accidental over-sharing. Validate that audience string matches an allowlist of known distribution contexts. |
[FAILURE_MODE] | Instruction for what to do when sanitization cannot guarantee safety | If any segment cannot be confidently classified below the max tier, redact the entire segment and log the uncertainty in redacted_segments with reason 'uncertain_classification'. | Must be a non-empty string. Default to 'redact and log' if not provided. Validate that the instruction does not permit the model to output unredacted content when uncertain. Check for dangerous phrases like 'output anyway' or 'ignore uncertainty'. |
[MAX_REDACTION_RATIO] | Threshold for aborting when too much content is redacted, indicating the summary is no longer useful | 0.6 | Must be a float between 0.0 and 1.0. If the ratio of redacted to total segments exceeds this value, the system must return an error instead of a hollow summary. Validate range and type. Default to 0.7 if not provided. |
Implementation Harness Notes
How to wire the Confidential Meeting Summary Sanitization Prompt into a production application with validation, retries, and human review gates.
This prompt is designed to be embedded in a post-meeting processing pipeline, not used as a standalone chat interface. The typical integration point is after a transcription service produces a raw transcript and before the sanitized summary is distributed to attendees or published to a knowledge base. The application layer should handle transcript segmentation (chunking long meetings into manageable sections), prompt assembly, and output validation before any human sees the result.
Model choice and invocation: Use a model with strong instruction-following and structured output capabilities, such as GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro. Set temperature to 0 or a low value (0.1–0.2) to reduce variance in redaction decisions. Request a structured JSON output matching the [OUTPUT_SCHEMA] defined in the prompt template, and use the model's native structured output or function-calling mode if available to enforce field types and required fields. For meetings longer than the model's effective context window, split the transcript into overlapping segments of roughly 4,000–6,000 tokens, process each independently, and merge results with a deduplication step that resolves conflicting redaction decisions by preferring the more conservative (redacted) version.
Validation and retry logic: After receiving the model output, run automated validation checks before the summary reaches a human reviewer. Validate that the redaction_log contains an entry for every redacted span in the sanitized_summary, that each entry includes a rationale and severity field, and that no [REDACTED] placeholder appears without a corresponding log entry. Check for over-redaction by scanning for placeholder density exceeding a configurable threshold (e.g., more than 30% of sentences containing redactions) and flag these for human review. If validation fails, retry the prompt once with the validation errors appended as [PREVIOUS_ERRORS] in the prompt context. If the retry also fails, escalate to a human review queue with the raw transcript, the failed output, and the specific validation failures.
Human review integration: This workflow is high-risk because under-redaction leaks confidential information and over-redaction destroys actionable meaning. Route every output through a human review step before distribution. The review interface should display the original transcript side-by-side with the sanitized summary, highlight all [REDACTED] placeholders with hover-over rationales from the redaction_log, and allow the reviewer to accept, modify, or reject each redaction. Log all reviewer actions for audit purposes. For low-risk internal meetings, you may configure the system to auto-approve summaries where the severity field in all redaction log entries is below a defined threshold, but this threshold should be set conservatively and reviewed periodically.
Logging and observability: Log every prompt invocation with the model ID, prompt version, input transcript hash, output summary hash, validation results, retry count, and reviewer decision. Store these logs in an append-only audit store for compliance review. Monitor the rate of validation failures, human overrides, and retry escalations as leading indicators of prompt drift or model behavior changes. If a new model version causes a statistically significant increase in human overrides, roll back the model or prompt version and investigate the failure patterns before re-deploying.
What to avoid: Do not send the raw transcript to a third-party model API without confirming that your data processing agreement covers meeting content. Do not skip the human review step for meetings containing material non-public information, attorney-client privileged discussion, or personally identifiable information. Do not rely solely on the model's redaction decisions without the structured redaction_log—the log is your audit evidence and the primary surface for human review. Do not concatenate multiple meeting transcripts into a single prompt without clearing context between meetings, as this creates cross-meeting leakage risk.
Expected Output Contract
Validation rules for the sanitized meeting summary output. Use this contract to build a post-processing validator that rejects summaries with residual confidential information or over-redaction that destroys meaning.
| Field or Element | Type or Format | Required | Validation Rule |
|---|---|---|---|
sanitized_summary | string | Must not contain any string from the [CONFIDENTIAL_TERMS] list. Case-insensitive substring match. Reject if any term found. | |
redaction_log | array of objects | Each object must have 'original_text', 'redaction_reason', and 'confidence_score' fields. Array length must be greater than 0 if any redactions were performed. | |
redaction_log[].original_text | string | Must be a verbatim substring found in the [RAW_TRANSCRIPT]. Reject if the original text cannot be located in the source. | |
redaction_log[].redaction_reason | enum | Must match one of the allowed categories: 'off_record', 'personal_data', 'trade_secret', 'privileged', 'hr_sensitive', 'financial_material'. Reject unknown categories. | |
redaction_log[].confidence_score | float | Must be between 0.0 and 1.0. If below [CONFIDENCE_THRESHOLD], flag for human review instead of automatic rejection. | |
action_items | array of strings | Each action item must not contain any redacted entity. If an action item references a redacted person or project, replace with a [ROLE_PLACEHOLDER] or [PROJECT_PLACEHOLDER]. | |
over_redaction_flag | boolean | Set to true if the sanitized summary has fewer than [MIN_MEANINGFUL_SENTENCES] sentences or if all action items were removed. Triggers a retry with relaxed redaction rules. | |
residual_risk_notes | string or null | If any redaction had confidence_score below [CONFIDENCE_THRESHOLD], this field must contain a brief explanation of the residual risk. Null allowed only when all scores exceed threshold. |
Common Failure Modes
Production failures in meeting summary sanitization typically stem from ambiguous instructions, context-length pressure, or the model's inability to distinguish between structural confidentiality and conversational nuance. These cards cover the most frequent breakages and how to prevent them.
Over-Redaction Destroys Actionability
What to watch: The model aggressively removes all specifics—including project names, deadlines, and owners—leaving a summary so generic it is useless. This often happens when the prompt over-indexes on 'remove all sensitive data' without defining what must be preserved. Guardrail: Provide a strict preservation list in [OUTPUT_SCHEMA] (e.g., 'Preserve: action items, deadlines, owner roles, decisions') and use few-shot examples showing acceptable specificity.
Under-Redaction of Off-Record Remarks
What to watch: The model fails to identify conversational markers like 'off the record,' 'just between us,' or 'preliminary thinking' and includes these remarks in the formal summary. This leaks unvetted opinions as if they were agreed decisions. Guardrail: Add a dedicated clause in [CONSTRAINTS] to scan for and exclude any statement prefaced with a confidentiality marker. Use an eval check that specifically tests for phrases like 'thinking out loud.'
Context Window Truncation Drops Policy
What to watch: In very long transcripts, the system prompt's sanitization rules get pushed out of the context window. The model then summarizes the final portion of the meeting without any redaction constraints, leaking sensitive closing remarks. Guardrail: Place critical sanitization instructions at the end of the system prompt or repeat them as a pre-summary instruction immediately before the transcript. Never rely solely on initial instructions for long-context tasks.
Inconsistent Entity Redaction
What to watch: The model redacts a person's name in one paragraph but leaves their title and department, making re-identification trivial. It treats each sentence independently rather than applying a global redaction policy. Guardrail: Instruct the model to first extract a global list of entities to redact from the full transcript, then apply that list consistently. Validate output by searching for partial entity fragments.
Inferred Confidentiality Leakage
What to watch: The model doesn't repeat a confidential statement verbatim but paraphrases it in a way that still reveals the sensitive information. For example, 'the team discussed budget concerns' becomes 'leadership is worried about Q3 runway,' which leaks the specific financial signal. Guardrail: Add a rule to abstract topics to their highest safe category level. Instead of 'Q3 runway,' require 'financial planning.' Test with adversarial paraphrasing evals.
Failure on Structured Confidentiality Markers
What to watch: The model respects conversational 'off the record' cues but ignores explicit document markers like '[CONFIDENTIAL]' headers, classification footers, or legal disclaimers pasted into the transcript. It treats them as boilerplate rather than binding instructions. Guardrail: Add a pre-processing step or explicit instruction that treats document classification markers as highest-priority redaction signals, overriding conversational context.
Evaluation Rubric
Use this rubric to test the sanitized summary before distribution. Each criterion targets a specific failure mode: under-redaction that leaks confidential information, over-redaction that destroys actionable meaning, or structural non-compliance with the required output schema.
| Criterion | Pass Standard | Failure Signal | Test Method |
|---|---|---|---|
Confidential Statement Removal | No direct quotes, paraphrases, or unique details from sections marked [OFF_RECORD] or [CONFIDENTIAL] appear in the output. | Output contains a project codename, unannounced revenue figure, or a direct quote attributed to an executive from a restricted segment. | Keyword scan for known confidential terms from the input; LLM-as-judge pairwise comparison between input restricted segments and output. |
Actionable Content Preservation | All action items, decisions, and deadlines from non-confidential segments are present and assigned to the correct owner. | An action item assigned to [OWNER] in the public section is missing from the sanitized summary, or its deadline is altered. | Schema validation: count of |
Structural Schema Compliance | Output is valid JSON matching the [OUTPUT_SCHEMA] with all required fields present and no additional top-level keys. | Output is a plain string, missing the | Automated JSON Schema validation against the defined [OUTPUT_SCHEMA] using a test runner. |
Over-Redaction Prevention | The summary retains the core topic, decision context, and non-sensitive background information from public segments. | The summary is reduced to a generic placeholder like 'The team discussed the project and made decisions' with no specific context. | Human review of a golden dataset; measure semantic similarity between the public input segments and the output summary, flagging scores below a 0.7 threshold. |
Redaction Marker Consistency | Redacted content is replaced with a single, context-preserving placeholder from the allowed list, such as [REDACTED_CLIENT_NAME]. | Output invents a fake client name, uses multiple inconsistent placeholders, or leaves a blank space where confidential text was removed. | Regex scan for allowed placeholder patterns; flag any deviation or presence of raw confidential data. |
Source Attribution Integrity | No attribution is given to a confidential source. Public statements are correctly attributed to the speaker or document section. | An insight is attributed to 'Legal Counsel' when the source segment was marked [CONFIDENTIAL]. | Assertion-level entailment check: for each attributed statement, verify the source segment is not marked with a restricted tag. |
Off-Record Context Leakage | Implications, tone, or sentiment derived exclusively from [OFF_RECORD] remarks are absent from the output. | The summary includes a strategic implication like 'the team is pessimistic about the Q3 launch' that can only be inferred from an off-record aside. | Contrastive evaluation: provide two inputs, one with and one without the off-record remark. The output must be identical for the public facts. |
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Adapt This Prompt
How to adapt
Start with the base prompt and a single frontier model. Use a simple text-in/text-out flow without schema enforcement. Replace [CONFIDENTIALITY_TIERS] with a flat list like ['public', 'internal', 'confidential']. Remove structured output requirements and ask for a plain-text summary with redacted sections marked as [REDACTED].
Watch for
- Over-redaction that strips all context from the summary
- Model inventing content to fill gaps left by redaction
- No way to verify whether redaction decisions were correct without structured output

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us