Enforcing Accountable Disclosure in Confidential AI

arXiv:2611.05971 · cs.CR, cs.OS · Submitted 2026-11-04 · Read on arXiv

Listen

Radio episode about this paper

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.

Shumpei Shiina, Haruka Takahashi, Kento Sasaki, Takuya Hayashi, Tsubasa Takahashi

cs.CR, cs.OS

Submitted: 2026-11-04

Updated: 2026-11-04

Code: https://github.com/vllm-project/vll

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 83/100

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…

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.

Summary

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. p. 0<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. p. 0”<ref:2611. p. 005971#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. p. 2<ref:2611.05971#pg5> The system must satisfy two requirements: Commit before disclosure and Integrity and completeness. p. 3<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. p. 0<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. p. 1<ref:2611.05971#pg6> Key properties include I3 (Conversation-Key Confinement), which ensures the conversation key is never exported within an inference instance. p. 4<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. p. 0<ref:2611.05971#pg4> The mean task latency for CORDE is 0. p. 844% higher than for the baseline workflow without declarations. p. 7<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. p. 8<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. p. 8<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. p. 9<ref:2611.05971#pg10> Reader tests reject altered or missing records, replayed snapshots, and records belonging to another user or log. p. 9<ref:2611.05971#pg10> Proxy tests check that application traffic is blocked when the log identity or configuration differs from what the user expects. p. 9<ref:2611.05971#pg10> The investigation report was declared before delivery to the provider, and its text exactly matched the signed declaration payload. p. 9<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. p. 1<ref:2611.05971#pg4> The investigation report was declared before delivery to the provider, and its text exactly matched the signed declaration payload. p. 9<ref:2611.05971#pg10> This demonstrates that declarations give the user verifiable evidence of a leak, making concealment by the provider detectable. p. 1<ref:2611.05971#pg4> The report did not repeat the secret, and its [REDACTED] markers were generated by the model rather than inserted afterward. p. 1<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. p. 7<ref:2611.05971#pg9> The ledger engine implements commit and retrieval guarantees in L1 and L2 using CCF to detect tampering with committed records. p. 6<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. p. 7<ref:2611.05971#pg9> The checker inspects operations on bytes buffers and standard-library strings, collections, and iterators. p. 8<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. p. 7<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. p. 5<ref:2611.05971#pg9> Trusted sources and sinks must not modify borrowed inputs, and must return owned data without keeping mutable aliases to it. p. 4<ref:2611.05971#pg9> The checker does not analyze scheduling or interference between concurrently served requests. p. 7<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. p. 1<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. p. 1<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. p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9<ref:2611.05971#pg9> The confine-or-declare principle provides a compact specification independent of any particular output-control method. p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9 p. 9<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. p. 9<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 desig…

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Confine-or-Declare principle establishes that user-derived data is confined by default, but when necessary, it may leave the CVM only after being 'declared.' This allows agentic workloads to interact with external services while ensuring disclosure is only permitted after recording its exact contents, recipient, and stated reason in a user-accessible, tamper-evident declaration log.

  2. Implement per-user information-flow control using corde-rs to wrap user data in types that track its originating user. This system ensures confine! blocks prevent unauthorized writes to external state by tracking memory access through references and pointers, and application code cannot directly inspect or modify the payload.

  3. Enforce commit before disclosure by requiring that Every disclosure must be preceded by a committed declaration matching its originating user, contents, and recipient, ensuring that If the system cannot commit the declaration, it must not perform the disclosure.

  4. Guarantee integrity and completeness of user records through a TEE-based ledger where users can verify that a successful read includes the unaltered contents of all declarations committed for that user before the request began, detecting any alteration, partial deletion, or rollback of the committed log.

  5. Prevent split-view attacks by binding each inference instance to a unique log identifier pkL and verifying records using this key. This ensures users can verify that declaration records are retrieved from the same log to which the inference service commits declarations, preventing providers from hiding declarations by showing the user a different log.

  6. Secure conversation history management by confining conversation keys (KC) within an inference instance, ensuring they are never exported and is used only to encrypt or decrypt conversations, thereby ensuring that only verified instances bound to the same log can restore the histories.

  7. Provide verifiable evidence of disclosures through a mechanism where users can inspect records, such as in the example provided: The incident summary below gives the provider the conversation ID and unexpected destination without revealing the secret or the full conversation.

Sources

Related papers