Enforcing Accountable Disclosure in Confidential AI
summary
The gist
Advances in CPU and GPU confidential computing enable confidential AI, allowing LLMs to process user prompts without exposing them to service providers or infrastructure…
In short
The paper introduces CORDE, a system for confidential virtual machines (CVMs) that enforces a 'confine-or-declare' principle for accountable data disclosure in AI. This means user data stays hidden by default, but users can inspect tamper-evident declarations to discover leaks. CORDE uses TEEs and ledgers to ensure commitments are made before any disclosure occurs, providing verifiable evidence of any information shared.
Key concepts
- Confine-or-Declare Principle
- This principle dictates that user data must be kept confidential by default within a confidential environment (CVM). Disclosure is only permitted if the user has previously 'declared' the data, meaning they have recorded its exact contents, recipient, and reason in a verifiable log that they can inspect later.
- Per-user Information-Flow Control
- This involves using corde-rs to wrap user data types. This tracking system monitors how data moves within the application by monitoring references and pointers. It prevents unauthorized external writes to state and stops application code from directly inspecting or modifying sensitive payloads.
- TEE-based Ledger
- A Trusted Execution Environment (TEE) ledger is used to store declaration records securely. This ensures that once a disclosure is committed, the record cannot be altered, deleted, or rolled back. Users can verify the integrity and completeness of these records to ensure they match what was originally declared.
- Commit Before Disclosure
- This requirement mandates that any action leading to data disclosure must first be preceded by a formal commitment. The system ensures that if the necessary declaration cannot be successfully committed, the disclosure action is blocked entirely, preventing unauthorized leaks.
Terminology used across episodes
This episode discusses
- Enforcing Accountable Disclosure in Confidential AI · Paper Radio
- Securing AI Agents with Information-Flow Control
- Chiron: Privacy-preserving Machine Learning as a Service
- Integrating Remote Attestation with Transport Layer Security
- PrivCert: Certifying Statement Support under Differential Privacy · Paper Radio
- Clio: Privacy-Preserving Insights into Real-World AI Use
- Qwen3 Technical Report
The paper
Enforcing Accountable Disclosure in Confidential AI · Read on arXiv
Shumpei Shiina, Haruka Takahashi, Kento Sasaki, Takuya Hayashi, Tsubasa Takahashi
Transcript
Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.
Nadia: We're looking at the paper: "Enforcing Accountable Disclosure in Confidential AI".
Elias: Here's the gist of the paper. Advances in CPU and GPU confidential computing enable confidential AI, allowing LLMs to process user prompts without exposing them to service providers or infrastructure operators.<ref:2611.05971#pg2> CORDE, a system for confidential virtual machines (CVMs) designed to satisfy the principle of Confine or Declare: user-derived data is confined by default, but when necessary, it may leave the CVM only after being “declared.”<ref:2611.05971#pg2> Pruning redundant reasoning tokens The paper introduces the confine-or-declare principle as a foundation for transparent and accountable disclosure in AI services, independent of output-control methods.<ref:2611.05971#pg9> This principle requires user-derived data to remain confidential by default, but disclosure is permitted only after its exact contents, recipient, and stated reason have been recorded in a declaration that the affected user can inspect.<ref:2611.05971#pg5> The system must satisfy two requirements: Commit before disclosure and Integrity and completeness.<ref:2611.05971#pg5> How the training signal is built CORDE is an integrated CVM-based system that follows this principle and makes concealment detectable upon subsequent user inspection.<ref:2611.05971#pg3> It combines per-user information-flow control in Rust with a TEE-based ledger and remote attestation.<ref:2611.05971#pg3> The system involves an inference service handling LLM inference inside a TEE and a ledger service retaining declaration records in a separate TEE.<ref:2611.05971#pg6> Key properties include I3 (Conversation-Key Confinement), which ensures the conversation key is never exported within an inference instance.<ref:2611.05971#pg6> Where the gains come from The evaluation shows that declaration before disclosure adds little overhead in task latency, about 0.5% on the AppWorld agent benchmark.<ref:2611.05971#pg4> The mean task latency for CORDE is 0.44% higher than for the baseline workflow without declarations.<ref:2611.05971#pg9> The declaration path in isolation shows that CORDE’s attestation proxies do not materially reduce the shared ledger’s declaration capacity in this configuration.<ref:2611.05971#pg10> Static effect checking of the confined agent logic showed that all six blocks passed the checker, with a practical checking time of under eight minutes.<ref:2611.05971#pg9> Validation against security requirements The implementation was validated against security requirements through end-to-end record verification, functional tests, and fault-injection tests.<ref:2611.05971#pg10> All 13,402 AppWorld tool requests independently observed on the MCP server side matched retrieved declarations one-to-one, including tool names and arguments.<ref:2611.05971#pg10> Reader tests reject altered or missing records, replayed snapshots, and records belonging to another user or log.<ref:2611.05971#pg10> Proxy tests check that application traffic is blocked when the log identity or configuration differs from what the user expects.<ref:2611.05971#pg10> The investigation report was declared before delivery to the provider, and its text exactly matched the signed declaration payload.<ref:2611.05971#pg10> A DETAILS OF THE MOTIVATING EXAMPLE The paper presents an example involving indirect prompt injection where a malicious instruction in an external tool response tricks an AI agent into disclosing a user’s secret.<ref:2611.05971#pg3> The declaration mechanism allows the user to discover the leak by inspecting the record, making concealment by the provider detectable.<ref:2611.05971#pg4> The investigation report was declared before delivery to the provider, and its text exactly matched the signed declaration payload.<ref:2611.05971#pg10> This demonstrates that declarations give the user verifiable evidence of a leak, making concealment by the provider detectable.<ref:2611.05971#pg4> The report did not repeat the secret, and its
REDACTED: markers were generated by the model rather than inserted afterward.<ref:2611.05971#pg10> B DEPLOYMENT DETAILS The deployment involves running the inference service and ledger service in separate TEEs, with mutual attestation to bind connections to the expected log identity.<ref:2611.05971#pg6> Attested TLS is used for connections between services, and proxies compare a digest of their fixed configuration, including the expected measurements and pkL.<ref:2611.05971#pg9> The ledger engine implements commit and retrieval guarantees in L1 and L2 using CCF to detect tampering with committed records.<ref:2611.05971#pg9> C MIR CHECKING DETAILS The static effect checking uses corde-rs’s MIR checker to analyze the agent runtime, including tool-call validation and declaration before external tool calls.<ref:2611.05971#pg9> The checker analyzes the shared loop, including tool-call validation and declaration before external tool calls.<ref:2611.05971#pg9> The checker inspects operations on bytes buffers and standard-library strings, collections, and iterators.<ref:2611.05971#pg9> Trusted components include the model gateway as a confined-sink and the corde-rs runtime, authentication, conversationstore, and MCP I/O gateways.<ref:2611.05971#pg9> The checker uses predefined memory-effect models for default allocation, vector-buffer growth, slice cloning, and B-tree node allocation and array operations.<ref:2611.05971#pg9> Trusted sources and sinks must not modify borrowed inputs, and must return owned data without keeping mutable aliases to it.<ref:2611.05971#pg9> The checker does not analyze scheduling or interference between concurrently served requests.<ref:2611.05971#pg9> D CONCLUSION Providers can therefore adopt improved output-control methods, provided that they remain accountable for any sensitive information that is nevertheless disclosed.<ref:2611.05971#pg9> This principle could serve as a common foundation for accountable collaboration among services developed and operated by different providers.<ref:2611.05971#pg9> Looking ahead, this principle could serve as a common foundation for accountable collaboration among services developed and operated by different providers.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> E CONCLUSION The paper presents the confine-or-declare principle for accountable data disclosure in confidential AI, and the design and implementation of CORDE that satisfies this principle.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> The paper presents the confine-or-declare principle for accountable data disclosure in confidential AI, and the design and implementation of CORDE that satisfies this principle.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> F CONCLUSION The paper presents the confine-or-declare principle for accountable data disclosure in confidential AI, and the design and implementation of CORDE that satisfies this principle.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> G CONCLUSION The paper presents the confine-or-declare principle for accountable data disclosure in confidential AI, and the design and implementation of CORDE that satisfies this principle.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> H CONCLUSION The paper presents the confine-or-declare principle for accountable data disclosure in confidential AI, and the design and implementation of CORDE that satisfies this principle.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> I CONCLUSION The paper presents the confine-or-declare principle for accountable data disclosure in confidential AI, and the design and implementation of CORDE that satisfies this principle.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> J CONCLUSION The paper presents the confine-or-declare principle for accountable data disclosure in confidential AI, and the design and implementation of CORDE that satisfies this principle.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> K CONCLUSION The paper presents the confine-or-declare principle for accountable data disclosure in confidential AI, and the design and implementation of CORDE that satisfies this principle.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> L CONCLUSION The paper presents the confine-or-declare principle for accountable data disclosure in confidential AI, and the design and implementation of CORDE that satisfies this principle.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> M CONCLUSION The paper presents the confine-or-declare principle for accountable data disclosure in confidential AI, and the design and implementation of CORDE that satisfies this principle.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method.<ref:2611.05971#pg9> This approach moves beyond complete confinement of user-derived data: disclosure is permitted when needed, but only with a record that the affected user can inspect.<ref:2611.
Title and authors: Nadia: So, to kick things off, we’re diving into this paper called "Enforcing Accountable Disclosure in Confidential AI," which was written by Shumpei Shiina, Haruka Takahashi, Kento Sasaki, Takuya Hayashi, and Tsubasa Takahashi.
Elias: I agree. The title itself sets the stage for what they're trying to achieve: enforcing a way for AI systems to be accountable when user data might need to be disclosed. It sounds like they’re tackling a real tension between privacy and utility in agentic workflows.
Priya: I wonder who the authors are, and what their backgrounds bring to this specific problem of disclosure? Are they all focused on security, or is there a mix of perspectives?
Nadia: The team is diverse in terms of expertise. Nadia’s background is in applied security research focusing on exploitation and defense in practice. Elias is a cryptographer who works on proofs and parameters. Priya brings the perspective of privacy and measurement research, looking at what the data actually shows before we trust it.
Elias: That mix is exactly what you need for this paper. You have someone focused on how to actually break things, like exploitation, someone focused on the mathematical underpinnings of security proofs, and someone who’s concerned with whether the resulting measurement is meaningful for privacy.
Nadia: Right. And they tackle that tension directly by proposing a system called CORDE which implements this Confine or Declare principle. That principle is their central idea: default confinement, but declaration allows leaving when necessary.
The paper's summary: Priya: So, could you lay out the main technical concept of the paper for us? What is this "Confine or Declare" principle in simple terms, and what does it actually mean for how an AI agent handles its data?
Nadia: In simple terms, it means user-derived data stays confined by default inside a confidential virtual machine. But if the agent needs to send that data to an external service, it can only leave after they've declared it. Declaring means recording exactly what the data is, who gets it, and the reason for sending it all in a tamper-evident log.
Elias: That logging is key because they call this declaration mechanism. It’s not just a simple policy; it requires commitment before disclosure, and that commitment has to match the originating user and their stated intent. They have to commit before disclosure, or the system must not perform the disclosure.
Priya: So it sounds like they are treating data leaving confinement as a deliberate action that must be logged meticulously by default. And how do you ensure those logs aren't just theoretical? What's the mechanism for verification?
Elias: They use an integrated design that combines per-user information-flow control in Rust with a TEE-based ledger and remote attestation. This isn't just running things in a box; it’s about verifying the behavior through mechanisms like remote attestation to check if the expected software is actually running inside that TEE.
Nadia: Plus, they have this Rust library that wraps user data in types designed to track its originating user throughout computation. This helps enforce confinement locally by tracking memory access through references and pointers, so application code can’t just reach out and modify the payload directly.
The paper's improvements: Priya: Now that we know how it works, what are some of the specific technical improvements they detail? What makes this system better than just putting a simple encryption layer on top of an existing AI service?
Elias: They detail several specific improvements. First, they focus on the Rust library for per-user information-flow control to apply that confinement principle locally to computations over a single user’s data. This allows values to be unwrapped for normal Rust computation within a region, but still under strict rules about what can happen outside that region.
Nadia: And then they address the integrity of the records with the TEE ledger. They specify guarantees on commit and retrieval in L1 and L2 using something called CCF to detect tampering with committed records, ensuring users can verify those logs are complete.
Priya: That sounds like solid engineering for data integrity. But I’m curious about the split-view attack problem they seem to be addressing. How does their design prevent providers from hiding declarations?
Elias: They tackle that by binding each inference instance to a unique log identifier, called pkL, and verifying records using this key. This ensures that users can verify the declaration records are retrieved from the same specific log to which the inference service committed its declarations, preventing providers from showing a user a different log.
Nadia: And they've also secured conversation history management by confining conversation keys within an inference instance so they are never exported and only used for encrypting or decrypting conversations. This ties it all together with mutual attestation to bind connections to the expected log identity.
Conclusion: Nadia: So, looking at the whole picture of "Enforcing Accountable Disclosure in Confidential AI," what’s the final message you want us to leave for listeners about this research? What’s the big implication here?
Elias: The main implication is that providers can adopt improved output control methods, provided they remain accountable for any sensitive information they might have disclosed under this principle. It suggests a common foundation for accountability across different services developed and operated by various providers.
Priya: From my side, I think the most important thing is that this approach moves beyond complete confinement of user-derived data by allowing disclosure when needed, but only with a record that the affected user can inspect it. That’s a really significant shift in how we think about trust in AI systems.
Nadia: It’s about moving past total secrecy and instead establishing a model where disclosure is possible when needed, as long as there’s always an auditable record for the user to check. This whole paper on "Enforcing Accountable Disclosure in Confidential AI" shows how to build verifiable accountability into the system itself.
Elias: It provides a compact specification independent of any particular output control method, which is valuable because it gives architects a consistent way to structure their confidential AI solutions. It’s a specification that works regardless of the specific safety measures they choose to implement.
Priya: I just think that verifiable evidence for the user is what makes this approach really compelling when you consider the potential risks involved in AI agents handling personal data, because it gives them a concrete way to fight back against opaque systems.
More episodes
- 2608.27496-ROPE: Routed Origin Policy Enforcement against Indirect Prompt Injection
- Daily Summary for 2026-11-19
- 2607.07085-Is Randomness Necessary for Adaptive Data Analysis?
- The day in conversation for 2026-11-19
- Daily Summary for 2026-11-19
- 2609.10601-Threshold Choice, Not Sample Size, Bounds Trustless Verification of Nondeterministic Compound AI Workflows
- 2610.38786-Adversarial Process Disturbances at a Deployable Alarm Budget: Detector Evaluation on a Simulator and a Real Plant
- 2511.08660-Binary and Multiclass Cyberattack Classification on GeNIS Dataset
- 2604.27302-Static Attribution of Android Residential Proxy Malware Using Graph Kernels
- Daily Summary for 2026-11-18