On Seeding Watermarks to Detect Verbatim LLM Copy-Paste Responses

summary

The gist

Large language models (LLMs) have made fluent essay writing, code drafting, and quiz answering instantly available to students at every level from secondary school through graduate study…

In short

SteganoPrompt embeds an invisible watermark inside assignment prompts using deprecated Unicode tags. An LLM reads this watermark to insert a detectable signature into its reply if it copies and pastes the prompt verbatim. This method aims to detect direct copy-paste cheating by creating an inputside detection mechanism.

Key concepts

SteganoPrompt
This is an inputside watermarking technique where a hidden, printable-ASCII message is encoded directly into the visible text of an assignment prompt using specific Unicode blocks. The goal is to leave the text visually unchanged while embedding a secret signal for detection.
Inputside Watermarking
Instead of marking the output, this method modifies the input (the prompt) before it reaches the LLM. SteganoPrompt achieves this by encoding data into unused Unicode tags, making it an 'invisible' modification that triggers a specific response from the model.
Channel Survival
This refers to how well the embedded watermark survives common text processing steps, like copying and pasting or passing through different text-editing pipelines. The technique is designed to ensure the hidden payload remains intact even when the prompt is manipulated by students.
Cross-Model Compliance
This measures whether different large language models (like Claude or Gemini) correctly recognize and respond to the hidden instruction embedded in the SteganoPrompt watermark. The paper found that some models respected these hidden instructions while others did not.

Terminology used across episodes

This episode discusses

The paper

On Seeding Watermarks to Detect Verbatim LLM Copy-Paste Responses · Read on arXiv

George Washington University

Large language models (LLMs) have made fluent essay writing, code drafting, and quiz answering instantly available to students at every level, from secondary school through graduate study. Many educators do not object to LLM use per se; what they need to detect is the case in which a student pastes the assignment prompt into a chatbot and submits the model's reply verbatim, without engaging with the work. Existing post-hoc AI-text detectors remain unreliable and have been shown to penalise non-native English writers, while output-side watermarks require cooperation from the model provider. We propose an alternative that the educator controls directly: an input-side watermark in which an invisible instruction is embedded inside the visible assignment prompt itself. An LLM that ingests the prompt verbatim quietly reads the hidden instruction and writes a tell-tale signature into its reply, exposing the copy-and-paste pathway specifically. We describe SteganoPrompt, a single-page, zero-dependency web tool that encodes an arbitrary printable-ASCII payload into the deprecated Unicode Tags block (U+E0000--U+E007F). The encoded string is visually identical to the original, survives common copy-paste channels (Word, Google Docs, PDF, Markdown, Slack, e-mail, the major learning-management systems), and is tokenized as ordinary text by most frontier models. We evaluate compliance across eight LLM families and a representative set of educational content channels. To keep deployment transparent, disclosure is built into the tool itself: every encoded brief also carries a brief, always-on academic-integrity reminder for the student, and we set out concrete guidance recommending for its disclosed, ethical use in the classroom. The tool is released under the MIT licence at https://ezharjan.github.io/SteganoPrompt/.

DOI: 10.1609/aies.v9i1.43126

Transcript

Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.

Nadia: We're looking at the paper: "On Seeding Watermarks to Detect Verbatim LLM Copy-Paste Responses".

Elias: Here's the gist of the paper. Large language models (LLMs) have made fluent essay writing, code drafting, and quiz answering instantly available to students at every level from secondary school through graduate study <ref:2605.16336#pg2>.

Nadia: Many educators do not object to LLM use per se; what they need to detect is the case in which a student pastes the assignment prompt into a chatbot and submits the model’s reply verbatim without engaging with the work <ref:2605.16336#pg3>.

Elias: The paper proposes SteganoPrompt, an inputside watermark embedded inside the visible assignment prompt itself, which an LLM reads to write a tell-tale signature into its reply specifically exposing the copy-and-paste pathway <ref:2605.16336#pg2>.

Nadia: The Problem with Existing Detection Methods Existing posthoc AI-text detectors remain unreliable and have been shown to penalise non-native English writers, while output-side watermarks require cooperation from the model provider <ref:2605.16336#pg3>.

Paper summary: Nadia: So we're talking about this paper called "On Seeding Watermarks to Detect Verbatim LLM Copy-Paste Responses." Essentially, they’re looking at how students are using AI to write essays and the problem is that teachers can't easily tell when a student just pastes the whole assignment prompt into a chatbot and turns in the AI's reply without actually doing any of the work >

Elias: Exactly. The paper says existing methods for spotting this, like those looking at text after it’s been written, aren't very reliable because they can end up punishing students who write in a way that isn't standard English or non-native speakers have >

Priya: And output watermarks are another problem because you need the model provider to cooperate, which most teachers don't have control over for their classrooms >

Nadia: So what they propose is something different. They suggest an inputside watermark, meaning they embed an invisible instruction directly into the assignment prompt itself, and if an AI reads that prompt verbatim it writes a secret signature into its response to expose the copy-paste pathway >

Elias: That specific technique is called SteganoPrompt, and it uses a method where they encode something printable in ASCII into those Unicode tags block U+E0000 to U+E007F which looks exactly like the original text >

Nadia: It sounds like they're trying to create a channel that the student doesn't even see, so if an AI ingests the prompt verbatim, it quietly reads that hidden instruction and writes a tell-tale signature into its reply >

Elias: The method involves setting A equal to Ap union Aw and defining T as c plus zero E000 colon where C is in A >

Priya: I'm wondering about the practical side of this. If the goal is to detect verbatim copying, how does this inputside approach actually survive the process of a student using it? >

Nadia: Well, they focused on making sure it has visual identity and that it survives common distribution pipelines, which means testing if it gets stripped out by different text-editing tools >

Elias: They found that models like Claude and Gemini emitted this integrity token in every trial, but GPT series showed none because of something called input scrubbing >

Priya: That's interesting about the model compliance. But what about the channel survival part? Does it actually stay intact when people copy that text to different places? >

Nadia: They found that the payload is preserved through every text-editing pipeline they tested, with only some social platforms stripping extended Unicode characters >

Elias: They also mentioned linguistic steganography as another area, like using context-aware lexical substitution to trace where a passage came from, but they noted those methods change the wording which isn't what you want for an assignment brief that needs to stay verbatim >

Priya: So the Unicode tag approach is different because it modifies the byte stream while leaving every rendered glyph unchanged, which keeps the text looking normal >

Nadia: Right. And they built this tool as a single page web tool that does all the computation right in your browser, which makes it pretty accessible for someone trying to test this out >

Elias: The recommended way to use it involves four steps: first disclosing the policy in the syllabus, second encoding each brief with SteganoPrompt and pasting it into the learning management system, third verifying before releasing by decoding the brief to confirm the payload is bitidentical, and finally searching submissions for that literal token at grading time >

Priya: I wonder about that verification step. If you decode it to check for a bitidentical payload, does that really give you confidence in catching someone who might be slightly altering the prompt? >

Nadia: The paper argues that this workflow generalizes the manual word of the day check without needing visible student action, which is a big deal for teachers trying to keep up with this AI use >

Elias: Beyond just detecting verbatim copying, they framed it as an alternative that you control directly, sitting between output watermarking and indirect prompt injection attacks >

Priya: What are the ethical considerations here? The paper touches on the need to disclose the policy to have a deterrent effect and using a kind payload that doesn't embarrass students if they make a mistake >

Nadia: They suggest that if someone hits this watermark, it should be treated as a starting point for conversation instead of an immediate verdict on their integrity >

Elias: And they are careful about using the technique against systems you don't own or haven't been authorized to test because it can be used in adversarial ways, like indirect prompt injection >

Priya: So, what’s the actual future direction for this work? What do they suggest doing next after proving this inputside watermark works for detecting copy-paste? >

Nadia: They suggested embedding an HMAC over assignment metadata to get stronger verification of the assignment itself >

Elias: They also proposed combining that Unicode-Tag channel with a content level watermark to help it survive light paraphrasing, and they plan a multi section, multi instructor field study to estimate the actual detection rates across different scenarios >

Priya: That sounds like a solid plan for getting more robust data on how effective this is in the real world, especially when dealing with different types of student work >

Conclusion: Nadia: So we're wrapping up this talk on "On Seeding Watermarks to Detect Verbatim LLM Copy-Paste Responses." Basically, the paper shows an inputside way to watermark assignment prompts so if an AI copies it verbatim, it leaves a traceable signature in its answer.

Elias: It’s about embedding something into the prompt itself that the AI reads and then writes back. The authors used something called SteganoPrompt which uses those unused Unicode tags block U plus E zero zero zero to U plus E zero seven f which looks exactly like normal text.

Priya: So, what does this mean for us? We're talking about making sure students aren't just pasting the whole question into a chatbot and submitting the AI's answer without doing the actual thinking.

Nadia: Right, it’s a direct way to check that specific copying behavior without having to look at the final essay text. The authors tested this across different language models like Claude and Gemini, and they saw that most of them put out this integrity token in every test run.

Elias: But the results weren't perfect. They found that some models, specifically a GPT series model, didn't show any token because it had some input scrubbing mechanism. That’s a big caveat for us to keep in mind when we talk about model compliance across the board.

Priya: So, even with this watermark on the prompt side, you still have to be careful about which AI you are testing against and how that specific model handles instructions before you can trust the detection. The data shows that channel survival is good; they found it stays intact through most text editing pipelines.

Nadia: It’s a tool sitting right between trying to detect what the AI writes and trying to control what the AI produces at output time. It gives educators a way to catch that direct copy-paste action during grading, which is currently pretty hard because of all the paraphrasing students do.

Elias: Exactly. The authors suggest this inputside watermark is a working classroom integrity tool, but they also point out it’s not perfect on its own. They plan more work to combine this Unicode channel with a content level watermark to handle light paraphrasing better.

Priya: And they’re looking at embedding something called an HMAC over assignment metadata for even stronger verification of the assignment itself before you even get to the student submissions. That suggests a layered approach might be needed here.

Nadia: So, this paper gives us a concrete method—SteganoPrompt—that allows instructors to search for that literal token at grading time, which is a big step toward making academic integrity checks more practical and less reliant on just looking at the final paper.

More episodes

← Home