The Acknowledgment Point Is the System: Durable Policy-Decision Receipts for AI Audit Evidence
This paper presents RuntimeGuard-AI, a research prototype that ensures durable and verifiable AI audit evidence by binding policy decisions to signed receipts at explicit synchronization boundaries, thereby offering a measured trade-off between low-latency buffered performance and high-integrity synchronous recording rather than a "free" asynchronous solution.
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
In the world of artificial intelligence, a system makes a decision in a flash, often in the time it takes to blink. But for that decision to be trustworthy, there must be a permanent record of it, one that cannot be erased if the power fails or the computer crashes. This is the core challenge of accountability: knowing exactly when a digital promise becomes a fact. If a computer tells a user, "I have saved the proof of what I just did," but the saving process is still happening in the background, that promise is fragile. A sudden crash could wipe the memory before the record is truly safe. Conversely, if the computer waits until the record is absolutely safe before speaking, the user might experience a noticeable delay. The question researchers face is not just how to write a log, but how to know, with certainty, when that log is unchangeable and ready to be trusted.
A team of independent researchers has built a new system to solve this specific timing problem, creating a prototype that treats the moment of acknowledgment as the moment of truth. Their work, called RuntimeGuard-AI, focuses on a simple but difficult rule: a computer should never tell a user that evidence exists until that evidence has actually survived a potential crash. To achieve this, they stripped away complex layers of proof that previous versions of the system relied on, rebuilding the engine from the ground up to be smaller, faster, and easier to test. The result is a system that binds every decision to a specific policy, writes a tiny, secure record to storage, and hands the user a signed receipt that explicitly states whether that record is safe or still vulnerable.
The researchers designed the system to offer three distinct ways of handling this trade-off, letting the user choose between speed and safety. In the fastest mode, the system writes the record to a temporary buffer and immediately returns a receipt that admits the data is not yet safe. This is useful for high-speed operations where a tiny risk of data loss is acceptable. In the other two modes, the system waits. It forces the computer to physically synchronize the data with the storage drive before returning a receipt that guarantees the record is durable, provided the operating system and storage hardware honor their documented semantics. One of these modes ensures the data is safe on the disk, while the other ensures the data is flushed to the storage controller, though the system explicitly does not claim immunity to remote replication or rollback. The researchers found that this choice is not free. When they tested the system on a modern computer processor with four worker threads and standard-sized prompts, the fast, buffered mode could handle about 27,193 requests per second with a delay of just 141.9 microseconds. However, when they switched to the mode that guarantees the data is safe on the disk, the speed dropped dramatically to about 242 requests per second, and the delay rose to 16.0 milliseconds. This gap is not a bug; it is a measured reality of how storage works. The system proves that you cannot have instant acknowledgment and guaranteed durability at the same time.
Beyond the speed tests, the researchers built a method to verify that these records have not been tampered with over time. They group thousands of these signed receipts into larger bundles called epochs. Each epoch is sealed with a cryptographic signature, creating a chain of evidence that an independent auditor can check. If someone tries to alter a past decision or delete a record, the chain breaks, and the signature no longer matches, though the system notes that a privileged operator with the ability to rewrite complete records could still bypass these checksums. The system also includes a rigorous recovery process. If the computer crashes and restarts, the engine automatically checks the records it finds, ensuring they are complete and in the correct order. It rejects any partial or corrupted data, refusing to start until it is sure the history is intact. In tests, recovering and validating a log of 100,000 records took less than a second, showing that the system can restart quickly without losing its mind about what happened before the crash.
The researchers were careful to define what their system does not do. It does not prove that the artificial intelligence model itself is thinking correctly or that the code running the decision is free from hidden viruses. It does not stop a hacker who has already taken over the entire computer from rewriting the history. Instead, it creates a tight link between a specific decision and a specific policy, ensuring that if the decision is recorded, it is recorded exactly as the policy dictated, though it cannot protect against the replacement of the implementation itself. The system acts as a precise accountant for AI actions, measuring the exact cost of safety in milliseconds and requests per second. It offers a clear, honest interface where the computer says, "I have saved this," only when it truly has, or "I have not," when it is still waiting. By making the durability of the record a visible part of the conversation, the system turns a vague promise of safety into a measurable, machine-checkable fact.
The final picture is one of clarity rather than magic. The system does not offer a free lunch where records are both instant and permanent. It forces a choice, and it measures the price of that choice with precision. The researchers found that sealing a large batch of 100,000 records into a single, signed epoch takes about 97 milliseconds, a small cost for creating a long-term, verifiable history. This work suggests that true accountability in AI requires accepting these delays and costs, rather than hoping to bypass them with clever tricks. The system stands as a practical tool for anyone who needs to know, with absolute certainty, that a digital decision has been preserved exactly as it happened, ready to be examined by an auditor or a court at any time in the future.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.