🤖 AI

Chronology of Multi-Agent Interactions for Provenance of Evolving Information

This paper proposes a post hoc attribution system using "symbolic chronicles" to track and chronicle the provenance of content generated by collaborative multi-agent systems, enabling accountability by embedding signed, time-stamped records directly into the synthetic content without relying on internal memory or external metadata.

Original authors: Ching-Chun Chang, Isao Echizen

Published 2026-05-01

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Ching-Chun Chang, Isao Echizen

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a group of writers sitting around a table, passing a single notebook back and forth to write a story together. Writer A starts a paragraph, then hands it to Writer B, who edits it, then to Writer C, who rewrites half of it, and so on. By the time the story is finished, the final text looks like one cohesive piece. But if you look at the notebook, there's no way to tell who wrote which part, or in what order. The original contributions have been overwritten, leaving no trace of the history.

This paper tackles that exact problem, but with AI agents instead of human writers. As multiple AI models collaborate to create content, the history of "who did what" often disappears. The authors propose a clever solution: a system that hides the "receipt" of every interaction directly inside the story itself, without needing any external logs or metadata.

Here is how their system works, broken down into simple concepts:

1. The Problem: The "Eraser" Effect

In a normal multi-agent AI chain, when a new agent takes over a task, it often rewrites the previous text to make it flow better. It's like a painter who paints over a previous artist's work to fix a mistake. Eventually, the canvas is covered in fresh paint, and the original layers are gone. If you want to know who painted what, you can't just look at the final picture; you'd need a separate notebook (metadata) to track the history. But what if that notebook gets lost, deleted, or separated from the painting? The history is gone forever.

2. The Solution: The "Invisible Ink" Chronicle

The authors propose a system called a Chronicle. Think of this as a secret code that is written into the story using "invisible ink" (statistical patterns in word choice) rather than visible text.

The Codebook: Imagine a giant dictionary where every word is assigned a specific color. For every possible combination of writers (e.g., "Writer 1 then Writer 2 then Writer 3"), there is a unique "color pattern" assigned to that sequence.
The Bias: When an AI agent is about to write the next sentence, the system whispers to it: "For this specific moment in the story, please lean slightly toward using words that match our secret color pattern."
The Result: The AI still writes a natural-sounding story, but it subconsciously chooses slightly different words than it normally would. These subtle choices form a hidden fingerprint that says, "I was written by Agent A, then Agent B, then Agent C."

3. The Feedback Loop: Updating the Receipt

The system works like a relay race where the baton is a secret message.

Start: The story begins with a blank slate (a "null" agent).
Step 1: Agent 1 writes a bit. The system updates the secret message to include "Agent 1" and embeds this new message into the text they just wrote.
Step 2: Agent 2 reads the text, sees the hidden "Agent 1" message, and updates the secret message to "Agent 1 → Agent 2." They then write the next part, embedding this new combined message into their text.
Repeat: This continues down the line. Every time the text is generated, the "receipt" of the entire history is updated and re-embedded into the new words.

4. The Detective Work: Decoding the Story

Later, if someone wants to know the history of the story, they don't need the original logs. They just take the final text and run a statistical analysis.

The decoder looks at the words used and asks: "Do these words match the pattern for 'Agent 1 then 2 then 3'?"
Because the AI was biased to pick specific words for that specific history, the statistical pattern will be strong enough to reveal the exact sequence of agents, even if the text has been edited or rewritten many times.

5. The Trade-off: Clarity vs. Perfection

The paper highlights a balancing act, like tuning a radio:

Strong Signal (High Bias): If you tell the AI to follow the secret code very strictly, the history is easy to read (high accuracy). However, the story might sound a little stiff or unnatural because the AI is forced to pick specific words.
Weak Signal (Low Bias): If you let the AI write more freely, the story sounds natural, but the hidden code is fainter and harder to detect, especially if the text gets edited or words are swapped out (like a synonym replacement).

6. What the Experiments Showed

The researchers tested this with a small group of AI "writers" (2 to 4 agents) writing a story in steps.

Accuracy: When they used a strong "bias" (telling the AI to follow the code closely), they could almost perfectly reconstruct the history of who wrote what, even after several rounds of rewriting.
Robustness: They tried to "break" the system by swapping words with synonyms (like changing "happy" to "joyful"). The system held up well if the bias was strong, but struggled if the bias was weak.
Complexity: The harder part is the math. As you add more agents or make the story longer, the number of possible histories explodes (like trying to guess a combination lock with more dials). This makes the decoding process computationally heavy for very long or complex chains.

Summary

In short, this paper introduces a way to embed a time-stamped, signed history directly into the DNA of AI-generated text. Instead of relying on external files that can be lost, the history is woven into the fabric of the content itself, allowing anyone to look at the final product and trace exactly which AI agents contributed to it and in what order.

1. Problem Statement

As Artificial Intelligence advances toward autonomous multi-agent systems, content is increasingly generated through collaborative chains where agents interact, revise, extend, or overwrite each other's contributions. A critical challenge arises in provenance tracking: determining the chronological history of which specific agent contributed to a piece of content at each step.

The Core Issue: In a generative chain, subsequent agents often overwrite prior content to maintain narrative flow or consistency. This process erases traces of previous contributions, leaving the final output with no inherent record of its evolutionary history.
Limitations of Existing Methods:
- Metadata/Logs: External logs (chain of custody) are fragile; they can be detached from content during transfer or corrupted.
- Fingerprinting: Cryptographic hashing is too sensitive to content changes (breaking under minor edits), while perceptual hashing lacks uniqueness.
- Watermarking: Standard zero-bit watermarking attributes content to a single source and struggles to determine the temporal order of multiple agents in a collaborative chain.

The paper seeks a method to embed a signed, time-stamped record of agent interactions directly into the generated text itself, without relying on external metadata or internal memory states.

2. Methodology: The Chronological System

The authors propose a system based on Symbolic Chronicles, which function as a steganographic "chain of custody" embedded within the text via biased token sampling.

A. Core Concepts

Chronicle ( $x$ ): A symbolic sequence of length $T$ (number of generation steps), where each symbol $x_t \in \{0, 1, \dots, n\}$ represents the identity of the agent active at timestep $t$ (0 denotes a null/unassigned agent).
Codebook ( $C$ ): A mapping where every valid chronicle $x$ $x$ is associated with a unique binary codeword $c(x)$ $c (x)$ of length $|V|$ $∣ V ∣$ (the vocabulary size).
- The codeword marks a sparse subset of the vocabulary (e.g., 50% of tokens are "marked" with a 1).
- The system uses a scalable construction strategy: generating unique base codewords in a reduced dimension $d$ and expanding them to the full vocabulary size via repetition and padding.

B. The Feedback Loop

The system operates through a recursive feedback loop involving three components:

Encoder (Generation):
- At timestep $t$ , the system retrieves the codeword $c(x^{(t)})$ corresponding to the current chronicle state.
- The agent (LLM) generates text based on a prompt.
- Biasing: The encoder modifies the model's logits. For every token $v$ in the vocabulary, if the corresponding bit in the codeword is 1, a bias $\delta$ is added to the logit ( $\tilde{\ell}_v = \ell_v + \delta$ ).
- This biases the sampling probability toward tokens associated with the current chronicle, embedding the agent's identity and the history of prior interactions into the text distribution.
Decoder (Retrieval):
- Given the generated text, the decoder tokenizes it.
- It calculates the frequency of "marked" tokens for every possible valid chronicle in the codebook.
- The chronicle with the highest frequency of matching tokens is selected as the reconstructed history ( $\hat{x} = \arg \max_x f(x)$ ).
Update Mechanism:
- After generation, the chronicle is updated to include the current agent's identity at position $t$ , shifting the "active" slot for the next step. This allows the system to track the full sequence $x^{(1)}, x^{(2)}, \dots, x^{(T)}$ .

3. Key Contributions

In-Text Provenance: A novel method to embed multi-agent interaction history directly into the semantic content of generated text, eliminating reliance on fragile external metadata.
Chronicle Formalism: The definition of "chronicles" as signed, time-stamped symbolic chains that evolve alongside the generation process.
Scalable Codebook Construction: A combinatorial strategy to generate unique codewords for a vast space of possible agent sequences without requiring prohibitive memory storage.
Post Hoc Attribution: The ability to reconstruct the entire generative history (who wrote what and when) solely from the final text output using statistical analysis.

4. Experimental Results

The system was evaluated using Llama (1B parameters) in a continual writing task with 2–4 agents over 3–6 timesteps.

Chronological Accuracy:
- With a bias strength ( $\delta$ ) of 3, the system achieved near-perfect accuracy (99–100%) across various configurations.
- Accuracy naturally degrades over time (error propagation) and with larger agent populations, but higher bias strength effectively mitigates this.
Generative Quality (Perplexity):
- There is a trade-off: Increasing bias strength improves attribution accuracy but increases perplexity (reducing text fluency/naturalness).
- However, the impact on perplexity stabilizes after the first generation step and is not heavily dependent on the number of agents.
Adversarial Robustness:
- The system was tested against lexical substitution (replacing words with synonyms, up to 70%).
- Low Bias ( $\delta=1$ ): Accuracy dropped rapidly, approaching random guessing.
- High Bias ( $\delta=3$ ): The system remained robust. For 2 agents, accuracy stayed above 90% even with 60% word substitution. Higher bias concentrates the sampling distribution on specific tokens, making the statistical signal resilient to semantic noise.

5. Significance and Future Directions

Trust and Accountability: This research provides a foundational mechanism for accountable AI. It ensures that in collaborative AI ecosystems, the origin and evolution of content can be traced, fostering transparency and trust.
Forensic Application: The method acts as a "digital chain of custody" for AI, allowing forensic analysis of synthetic content to determine if it was theoretically reasoned, empirically tested, or critically challenged by specific agents.
Limitations & Future Work:
- Scalability: The search space grows exponentially with agent count and chronicle length ( $|X| = (n+1)^T$ ), requiring efficient decoding or structural priors for large-scale systems.
- Homogeneity: Current experiments use identical models; future work must address heterogeneous agents with different vocabularies.
- Trade-offs: The tension between attribution accuracy and text quality (perplexity) requires tuning based on specific application needs.
- Robustness: Future research should explore robustness against more complex perturbations like syntactic restructuring, translation, or truncation.

In conclusion, the paper presents a viable, mathematically grounded framework for embedding multi-agent provenance into generative AI, transforming the text itself into a self-contained historical record of its creation.