Apply to my task
arXiv:2608.17051 ★ 83 Aug 17, 2026

Institution-Specific Prompting: how to tell the model your local secrets so it can find them

Key result

Finding: an LLM anonymizing text removes exactly what it was told to — not a word more. Institution-Specific Prompting lets you catch an organization's local slang — hospital abbreviations, building names, internal codes — that falls outside the standard 18 categories of personal data and therefore stays in the text untouched. Ask the model to look for specific local categories and give "don't remove this" examples — it applies the rule across the whole document instead of guessing. Result: about 4 out of 5 previously missed identifiers are found in a single pass.

01

TL;DR

A model that strips personal data from text behaves like a tourist with a phrasebook: it knows the standard phrases (names, dates, addresses) but doesn't get the local slang. Researchers showed that if you explicitly list local designations in the prompt (organization abbreviations, building names, internal codes) and give examples of what not to touch, the model finds almost everything it used to miss in a single pass.

The core pain: an LLM is good at scrubbing "classic" personal data but misses anything outside the standard list — the hospital abbreviation "TCH," the building name "Mark Wallace Tower," internal pager numbers. That isn't a limitation of the model — it simply was never asked to. When the prompt told it to remove only "the 18 HIPAA categories," it faithfully removed only 18 categories.

The fix isn't a fancy architecture but clarifying the task in two layers: first tell the model which additional local terms count as identifying, then give "Wrong → Right" pairs so it doesn't start deleting everything out of paranoia. Both layers go into the same prompt, with no extra passes.

Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.

02

Method Blueprint

STEP 1: Normal run — ask it to remove the standard categories of personal data → a first scrubbed version of the text
STEP 2: Look at what's still recognizable (abbreviations, codes, your organization's names) → a list of "blind spots"
STEP 3: One final prompt: standard categories + an explicit list of local categories + "don't remove this" examples → the finished result in a single request

All three steps fit in one chat: run it, look, add to the prompt, run it again with the clarifications.

03

Example in Action

Task: A startup is preparing internal correspondence and an incident report to hand to outside counsel before a deal (due diligence). Names and dates need to go — but so does internal slang: the meeting room "Caribbean Room," the department abbreviation "SLS" (sales), project codenames like "Project Mongoose," internal Jira ticket numbers.

Prompt:

You are an expert in anonymizing documents before they are shared with a third party.

In the text below, replace all identifying data with placeholders of the form [TYPE]:

Standard categories: people's names, dates, phone numbers, email, addresses, contract numbers.

Also replace designations specific to our company:
- Names of internal spaces and meeting rooms (e.g., "Caribbean Room")
- Department abbreviations ("SLS", "MKT", "ENG")
- Project codenames ("Project Mongoose")
- Internal ticket and task numbers (formats like PROJ-1234)

Do NOT remove the following — it doesn't identify the company or people:
- WRONG: "meeting at 2:00 PM" → RIGHT: keep it, this is not an identifier
- WRONG: "discussed the department's KPIs" → RIGHT: keep it, a generic term not tied to a specific person

If in doubt, remove it rather than leave something potentially recognizable.

Text:
{paste document}

Result: The model returns the text with placeholders instead of names, dates and local designations. Generic business terms (KPIs, reporting, meeting times) stay untouched. On a first run without the list of local categories, some internal slang ("Caribbean Room," "Project Mongoose") will most likely slip through — that's exactly why you need the second step with an explicit list.

04

Why It Works

The model can't guess that at your company "SLS" means "sales department" — it has never seen your internal dictionary. Without explicit instructions it faithfully follows the general rules and misses contextual details, because to it these are just ordinary words, not identifiers.

But the model is excellent at doing what it's explicitly told to do. Name a category once — "department abbreviations" — and the model applies that rule consistently across the whole text, even if the abbreviation shows up 20 times in different forms.

The method uses this strength directly: instead of hoping the model "figures out the context on its own," you point out specific categories plus examples of what not to touch. One request solves both problems — misses and over-deletion.

Control knobs: - The list of local categories — expand or narrow it for your document (legal, HR, financial) - "Wrong → Right" pairs — add your own specific cases of over-deletion - The doubt threshold ("if unsure, remove") — flip it if keeping the text readable matters more than maximum anonymity

05

Prompt Template

You are an expert in document anonymization.

Replace all personal and identifying data in the text below with placeholders of the form [DATA_TYPE].

Standard categories: people's names, dates, addresses, phone numbers, email, document numbers.

Also replace identifiers specific to {context: my company/organization/industry}:
- {category 1: e.g., abbreviations of the company and department names}
- {category 2: e.g., names of rooms, buildings, offices}
- {category 3: e.g., internal project codes, office numbers, internal designations}

Do NOT remove the following — it is not identifying information:
- {example 1: WRONG — ..., RIGHT — keep it}
- {example 2: WRONG — ..., RIGHT — keep it}

If in doubt, err on the side of removing too much rather than leaving something potentially identifying.

Text:
{document}

Put the type of organization or document into {context}, your local designations into {category} (you'll find them by running the document once and seeing what's still recognizable), and real cases where the model might over-delete into the "Wrong/Right" examples.

🚀 Quick start — paste into the chat:

Here is a template for anonymizing documents. Adapt it to my task: {your task}.
Ask me questions to fill in the fields.

[paste the template above]

The LLM will ask which local abbreviations, names and codes you have — because without that list it can't know what exactly in your document counts as a "local" identifier.

06

Limitations

⚠️ A preliminary step is required: the method doesn't work "out of the box" on the first prompt — first you have to run the document and manually find what's still recognizable, and only then write the final prompt with the list.

⚠️ The category list doesn't transfer automatically: one company's (or hospital's) local designations don't fit another. You need to build the list from scratch for each specific document.

⚠️ The method recovers most, not all: even with a refined prompt some misses remain — the model catches about 4 out of 5 cases, not all of them.

⚠️ Different models react differently: adding clarifying categories improves detection accuracy for some models and throws off the balance for others (they start missing more). Test it on your own model.

07

How They Studied It

The researchers took 100 clinical notes from pediatric oncology patients at a Texas hospital (5,322 annotated spans of personal data) and ran them through 8 different LLMs (Claude, GPT-oss, GLM, DeepSeek and others), as well as two specialized tools for removing personal data from medical texts. They compared three prompt variants: a baseline (per the HIPAA standard), one with added local categories, and one with added "what not to touch" examples.

The LLMs beat the specialized systems, and the gap was especially visible where context mattered rather than template-based recognition. Simply adding a list of local terms recovered almost 80% of the missed identifiers.

Separately, they tested 14 variants of multi-agent setups — where several LLMs work in a chain, checking each other (one "scrubs," another "verifies"). Not a single complex setup beat a simple prompt with good instructions. That's the key takeaway: the problem wasn't the architecture, it was how the task was worded.

The biggest surprise: when the researchers checked what exactly the LLMs found "above the bar" (things the human annotators hadn't marked), experts confirmed it was real personal data too — the humans had simply missed it during annotation. So a model with a good prompt found errors in the human-made gold-standard annotation.

08

Resources

Palacios D., Neeley M.B., et al. Institution-Specific LLM Prompting Recovers PHI That De-identification Systems and Their Gold Standards Both Miss. Baylor College of Medicine, Texas Children's Hospital.

Research digest

Key result

Finding: an LLM anonymizing text removes exactly what it was told to — not a word more. Institution-Specific Prompting lets you catch an organization's local slang — hospital abbreviations, building names, internal codes — that falls outside the standard 18 categories of personal data and therefore stays in the text untouched. Ask the model to look for specific local categories and give "don't remove this" examples — it applies the rule across the whole document instead of guessing. Result: about 4 out of 5 previously missed identifiers are found in a single pass.

Principle

In anonymization, an LLM isn't a context expert but a list executor. Say "remove the 18 HIPAA categories" and it kills exactly 18. Don't mention the abbreviation "TCH" or the building "Mark Wallace Tower" and it leaves them in — to the model they're just words, not identifiers. The principle: two layers in one prompt — a list of local categories plus "don't touch" examples — fix both misses and over-deletion in a single request.

Why it works

The model holds an explicit rule well and is bad at guessing subtext. Name a category once and it applies it to all 20 mentions in the text, even in different spellings. The model doesn't ignore context — it has simply never seen your internal dictionary. Without this step it faithfully follows the general standard and misses whatever the standard doesn't describe.

When to apply

Preparing documents for third parties → legal due diligence, HR archives, medical records with local abbreviations (organization acronyms, building names, internal codes). Especially needed when the document goes to an outside organization that doesn't know your internal jargon. Not a fit as a one-off pass without a preliminary check — first you need to manually find what's still recognizable.

Mini recipe

1. Run a draft: ask the model to remove the standard categories — names, dates, addresses. 2. Find the blind spots: eyeball the result — what's still recognizable? Abbreviations, codes, building names. 3. Add the list to the prompt: department abbreviations, meeting-room names, project codes. 4. Add "don't remove" examples: WRONG → RIGHT pairs so the model doesn't mow down generic terms like "KPI" or "meeting at 2:00 PM". 5. Run the final prompt as a single request: both problems — misses and over-deletion — are solved at once.

Examples

[BAD]: `Anonymize the document, remove personal data` — the model removes names and dates but leaves the abbreviation "TCH", the building "Mark Wallace Tower" and internal pager numbers, because it didn't know those were identifiers too. [GOOD]: `Replace the standard categories (names, dates, addresses) and additionally: the hospital abbreviation "TCH", the building "Mark Wallace Tower", internal pager numbers. Don't remove generic terms like "morning rounds" — that's not an identifier.` — now the model catches the local slang and doesn't mow down anything extra.

In plain words

Every standard data-anonymization system is blind to local context. They dutifully scrub obvious names, phone numbers and dates, but completely miss the inner workings of a particular organization. If a report mentions "meeting in Building B-4" or "cleared with SLS", to a baseline model that's white noise, not personal data. The result is an illusion of safety and leaky protection at the output.

It's like sending a foreigner with a pocket phrasebook to eavesdrop on locals in the neighborhood. Technically he speaks the language, but when people agree to "meet at the Bean", he goes looking for a coffee shop instead of the landmark downtown. A baseline model is exactly that kind of tourist who doesn't get the slang — it misses critical data simply because it doesn't know your crowd's context.

The cure for this failure is institution-specific prompting. You don't spend millions on fine-tuning; you load a dictionary of internal entities straight into the prompt: department acronyms, project codenames, ticket formats and meeting-room names. The second layer is always negative examples — so the model doesn't go haywire and erase half the useful text after deciding that an ordinary "crunch" is the lead engineer's last name.

The method was tested on medical records, but the principle is completely universal. Jira logs, Slack threads and incident reports get scrubbed the same way before they go to lawyers for due diligence. Every business quickly grows its own jargon. Hand those texts to standard tools and off-the-shelf maskers fall flat on their face, leaving both the secret "Project Mongoose" and employees' personal IDs in the documents.

Bottom line: stop blindly trusting "smart out-of-the-box algorithms" when privacy is on the line. Feed the model your company's specifics, or you'll get fake anonymization and a very real leak scandal. Either you spend five minutes on a prompt with a local dictionary, or you ship confidential data out the door disguised as a "clean" report.

AI lab assistant

Apply this study to your task

Describe what you're working on. AI takes the method and the measured results from this paper and adapts them to your case, or writes a ready prompt built on them.

Based on Institution-Specific Prompting: how to tell the model your local secrets so it can find them arXiv:2608.17051

Sign in to apply this study New accounts get 50 free credits.