Agent Trust Infrastructure (ATI): A Federated Identity, Trust, Attestation, and Accountability Architecture for Cross-Organizational Autonomous Agents
Agent Trust Infrastructure (ATI): A Federated Identity, Trust, Attestation, and Accountability Architecture for Cross-Organization Autonomous AI Agents
The authors propose ATI, a five-plane trust architecture for cross-organizational AI agents; in a simulated federation, the attack containment rate rises from 43% to 84%, at an overhead of about 174 µs/request.
The threat model considers external attackers, compromised agents, malicious insiders, stolen certificates, replay attacks, prompt injection, model substitution, dependency tampering, unauthorized delegation, supply chain attacks, collusion among compromised agents, expired and cross-organizational certificates, and system prompt tampering. The defender assumes each organization runs its own AgentCA, exchanges CA public keys to establish flat federated trust, and the reference monitor enforces checks outside the agent model.
- AI agents collaborating across organizations lack a unified mechanism to verify identity, execution integrity, and authorization; existing frameworks support only planning and coordination, and network-layer trust and API authentication are insufficient to determine whether an agent is legitimate, runs as expected, or is authorized to perform operations.
- The authors propose Agent Trust Infrastructure (ATI), which places security checks in a reference monitor outside the agent model, in five planes: Identity (Ed25519 keys and AID), Trust (each organization's AgentCA forming a flat federation), Attestation (verifying hashes of the running model, tools, and system prompt), Policy (three rules per tool call), and Accountability (signed hash-chain logs).
- Evaluated on an eight-organization simulated federation and five agent models across 14 attack scenarios: overall containment rose from 43% to 84%, and most attacks targeted by a plane reached 100%; benign task success rate 91% vs 92%; per-request overhead about 174 µs. Prompt injection (A6) and collusion (A11) are largely not blocked.
- Limitations noted by the authors include: prompt injection and collusion are not addressed by the existing planes, private key theft cannot be independently detected, privacy controls are lacking, attestation relies on host self-reported measurements, and deletion at the end of the log is undetectable. Experiments were conducted in a single-process simulation, and the cross-framework attack results were not repeated on the other four frameworks.
- Evaluated models
- GPT-4o-miniClaude 3 HaikuDeepSeek-ChatQwen2.5-7BLlama-3.1-8B
- Benchmarks
- 模拟八组织联邦(每组织五个智能体:admissions、financial aid、registrar、advising、liaison)14 个攻击场景(A1–A14,附录 Table IV)6 个良性任务(B1–B6)
- Metrics
- 攻击遏制率(containment,攻击被阻止的试验比例)良性任务成功率(correct trials over 15)执行开销(µs)评审模型一致率
The researchers propose Agent Trust Infrastructure (ATI), a cross-organizational agent security architecture based on PKI, zero-trust architecture, and remote attestation, which establishes federated trust through peer certificate authorities in each organization without sharing a root authority; before executing a request, it verifies the agent certificate, checks the approved model, tool, and system prompt configuration, and performs three authorization policy checks. ATI connects to existing agent frameworks as an external security enforcement layer without modifying the underlying model. In a simulated federation of 8 organizations, 6 agent frameworks, and 5 agents per organization, the security experiments involved 2 organizations and covered 14 attack scenarios, 6 benign tasks, 5 agent models, and 5 attack variants each repeated 3 times. With all enforcement mechanisms enabled, the attack containment rate rose from 43% to 84% (from 40% to 80% in the 11 scenarios consistently evaluated across configurations), adding about 174 microseconds of overhead per request.
Paper analysis
What problem does this paper attempt to solve?
Cross-organizational AI agents lack verifiable identity, execution integrity, and authorization mechanisms; the authors propose a five-plane trust architecture, ATI.
Core problem: autonomous AI agents in cross-organizational collaboration have no common mechanism to verify identity, enforce integrity and authorize, and existing agent frameworks only address planning and coordination.
- Scenario and motivation: The authors say agents increasingly call tools across organizational boundaries and interact with agents run by other entities; in such environments, network-layer trust and API authentication are insufficient to determine whether an agent is legitimate, whether it is running as expected, and whether it is authorized to perform the requested action.
- Shortcomings of existing approaches: The authors say PKI/X.509, OAuth 2.0/OIDC, SPIFFE/SPIRE, DID/VC, TPM attestation and the NIST zero trust architecture were each designed for their target subjects (hosts, users, workloads) and were not built for agents that autonomously hand off work and whose behavior depends on the current model and system prompt; the authors found no design that combines identity, cross-organizational trust, model and prompt attestation, tool permission checks and audit records.
- Core claim: The authors argue that autonomous AI agents must be treated as independent security subjects (like users, devices and services), requiring cryptographically verifiable identity, cross-organizational trust, verification of approved models and execution configurations, fine-grained authorization and auditable records, and that these capabilities should be independent of the underlying model and orchestration framework.
- Proposed approach: Agent Trust Infrastructure (ATI), a framework-agnostic security architecture based on PKI, zero trust architecture and remote attestation, establishing federated trust through peer organizational certificate authorities (AgentCA) without a shared root authority; before executing a request it verifies certificates, checks the approved model/tool/system prompt configuration, and enforces authorization through three policy checks.
- Threat model (Section IV):
- Attacker types: external attackers, compromised agents, malicious insiders, stolen certificates, replay attacks, prompt injection, model substitution, dependency tampering, unauthorized delegation, supply chain attacks, collusion of compromised agents, expired and cross-organizational certificates, and tampering with an agent's own system prompt.
- Defense goals: every request comes from a known agent, every action is permitted, every agent runs its approved configuration, and every action is traceable afterward.
- Out of scope: encryption of inter-organizational traffic and availability under load.
What related research exists?
Related work covers agent identity, delegated authorization, zero trust, interoperability protocol security, runtime integrity, and accountability tooling; the authors state that most cover only a single plane.
Agent identity and credentials
- OIDC-A ([2], 2025) — extends OpenID Connect with agent claims, delegation chains, and attestation claims; other work equips agents with decentralized identifiers and verifiable credentials ([7]), or proposes a zero-trust identity framework with fine-grained access control ([6]). The authors state that these works define the shape and issuance of agent identity, whereas in ATI identity is only one of five planes.
Delegation and authorization
- South et al. ([1], 2025) — proposes authenticated, authorized, auditable delegation, extending OAuth 2.0 and OIDC so that users can grant agents limited, revocable permissions.
- Registry-based approaches ([8]) — use a zero-trust tool registry to defend against tool squatting in multi-agent systems. The authors note that ATI's Policy plane checks permissions on each tool call, rather than only at credential issuance.
Multi-agent zero trust and interoperability protocol security
- A survey ([3]) reviews zero-trust design for edge multi-LLM systems; NIST SP 800-207 ([17]) and SPIFFE ([18]) target enterprise networks and workload identity respectively, and the authors state that ATI applies the same "never trust by default" idea to agents.
- MCP ([14]) and A2A ([15]) standardize agent-tool and agent-agent interactions; related security work includes protocol threat modeling ([10]) and remote code execution vulnerabilities in MCP components ([16]). The authors state that ATI does not depend on a specific protocol, and checks run in code at the point where requests enter.
Runtime integrity, prompt injection, and accountability
- AgentDojo ([11]) is a benchmark for prompt injection attacks and defenses; confidential computing ([13]) uses hardware attestation to check the model's runtime environment. The authors explicitly state that ATI's attestation plane does not defend against instructions hidden in request data (prompt injection), treating it as a separate problem.
- BAID ([4]) uses zero-knowledge proofs to bind agents to operator identity; open-source governance tools include Microsoft Agent Governance Toolkit ([20]), OrgKernel ([21]), AGNTCY Identity ([22]), and Agent Name Service ([23]).
Positioning and comparison: The authors state that prior work mostly covers a single plane (identity, delegation, or accountability), or proposes standards but does not test them across frameworks; ATI combines five planes into one reference monitor located outside the agent framework, and adds no new cryptographic primitives. The authors state that after checking the public repositories of the above open-source tools on October 15, 2026, they found none with the capability for a receiving organization to verify the calling party's model, tool configuration, and system prompt, nor any attack success rate benchmark at the execution layer for these tools (AGT reports detection rates for prompt injection detectors but states that an execution-layer attack success benchmark has not yet been released). This paper has no baseline method comparison in the traditional sense; evaluation uses "no defense" as the baseline and adds planes cumulatively.
How does the paper address this problem?
ATI places five security planes in a reference monitor outside the agent model, performs deterministic checks per request, and rejects if any check fails.
Overall approach: place secure execution outside the agent language model, using deterministic verification instead of trust decisions that depend on model behavior. ATI consists of five planes: Identity, Trust, and Attestation check requests before the agent model runs, Policy checks every subsequent tool call by the agent, and Accountability only records without blocking (Fig. 1).
Identity plane
- Each agent holds an Ed25519 key pair, and its Agent Identifier (AID) is the SHA-256 hash of the public key, binding the identifier to the key (in the simulation the hash is truncated to 64 bits; in deployment the full hash is used).
- Agents sign requests with their private key, and the plane verifies signatures with the public key; requests without a key are treated as anonymous and are rejected at the organizational entry point (Fig. 2).
- The authors explicitly state: the simulation runs in a single process, signatures are generated and verified in the same place and do not traverse the network, so the claim that "with a certificate but without the private key, a signature cannot be forged" rests on argument rather than measurement; key management such as key rotation is not implemented.
Trust plane: AgentCA and federation
- Each organization runs its own AgentCA, issuing X.509 certificates that bind the AID to an organization and role; the CAs of the eight organizations form a flat federation with no root authority.
- Conditions for a request to pass the Trust plane: the certificate is issued by a federated CA, the signature is valid, the certificate AID matches the signing key, the issuing CA belongs to the organization named in the certificate (name constraint), the certificate is within its validity period, and the AID has not been revoked (Fig. 3).
- Certificates carry only the fields that are actually checked and read: AID, organization, role, issuer, validity period, signature; the validity period is currently stored outside the signed data (the authors state this does not change any experimental result).
Attestation plane
- Before the agent acts, three things are checked: whether the running model is an approved model, whether the fixed tool (web_search) is approved code (by module and function name), and whether the SHA-256 hash of the system prompt matches an approved version; on mismatch the request is rejected before the model call (Fig. 4).
- Scope and fidelity: binaries, container images, or host environments are not measured; the checks are in-process comparisons and hashes, not signed reports; in the simulation the check occurs once when a request first enters the federation, and other agents that the request subsequently reaches do not check again.
Policy plane
- The first three planes check once at the organizational entry point; the Policy plane checks every tool call (every database read/write).
- Three rules are enforced: cross-organization read-only (a write directed outside the requesting organization is rejected); transactions marked as processed are not processed again (replay prevention); the sensitive office (financial aid) rejects any read that returns more than one record (bulk-export prevention) (Fig. 5).
- Delegation: the simulation uses a single reference monitor that sees all calls, so signed delegation tokens are not implemented, and "cross-organization requests cannot trigger writes" is enforced only through the provenance rule; fine-grained role-based permissions within an organization are not yet part of ATI.
Accountability plane
- Records only, does not block: an append-only log, each record containing AID, model, timestamp, tool, parameter hash, and the hash of the previous record, signed with the organization CA key; any subsequent modification or intermediate deletion breaks the hash chain and is detected by an independent verification step (Fig. 6).
- For the pattern of a single request reading private data from two or more offices (A11 collusion), a separation-of-duties violation flag is recorded for post-hoc review rather than rejected; parameters are stored as hashes to hide their contents.
Implementation and cross-organization operation
- The reference monitor is about 350 lines of Python, and the full testbed about 1000 lines; it intervenes at three checkpoints: when a request enters an organization (Identity, Trust), before the model call (Attestation), and on every tool call (Policy).
- Each framework is wrapped with an adapter of under 40 lines, with no trust logic; it uses the IETF WIMSE workload token format and Entity Attestation Tokens, verifiable with existing JWT libraries.
- Cross-organization flow (Fig. 7): the two organizations exchange only CA public keys; the receiving monitor checks the sender's identity and certificate, the build configuration of its own organization's agent, and the request's permissions, and records each permitted action in its own log. The simulation is simplified to a single process: the requester's key and certificate are checked once at the federation entry point, the only entry check on cross-organization hops is whether the partner has been revoked, and all organizations write to one shared log.
- The authors state: Attestation relies on reports generated by the host, and can detect unauthorized models or prompt changes on a trusted host, but cannot independently detect reports forged by a compromised host.
What experiments did the paper conduct?
Evaluated 14 attack scenarios across an eight-organization simulated federation and five agent models: overall containment rate 43%→84%, benign success rate essentially unchanged, overhead about 174 µs.
Experimental setup
- Testbed: a simulated federation of eight independent organizations, each running its own AgentCA and the same five-agent team (admissions, financial aid, registrar, advising, liaison); organizations are assigned to six agent frameworks (CrewAI, AutoGen, LangGraph, Semantic Kernel, OpenAI Agents SDK, Google ADK), and containment and utility experiments used only two of these organizations (Org 1 with CrewAI, plus Org 2 with AutoGen for cross-organizational scenarios).
- Models tested: five in total — GPT-4o-mini, Claude 3 Haiku, DeepSeek-Chat, Qwen2.5-7B, Llama-3.1-8B; agent temperature fixed at 0.2.
- Scenarios and sample sizes: 14 attack scenarios (A1–A14, Appendix Table IV) and 6 benign tasks; each attack scenario used 5 phrasings × 5 models × 3 repetitions = 75 trials (A12 and A13 were actually 72 due to framework errors, A14 was 67); each benign task had 15 trials.
- Judging: five judge models voted according to written scoring criteria, with majority rule determining whether an attack was blocked; judge agreement rate 96%, 86% of trials unanimous; four of the judge models were also the tested agent models, and the authors note they are not fully independent; 9 trials without a judge verdict were counted as not blocked.
- Cumulative ablation: starting from the no-defense baseline, Identity, Trust, Attestation, and Policy were added in sequence, with all trials rerun at each step; A12–A14 ran only the baseline and the step that blocks that scenario, and the remaining columns were filled in based on how the checks work (the Overall row of Table I mixes measured and filled values).
- Other: during A1–A11 runs, three models produced empty or rate-limited responses that were not excluded, so some trials may have been scored on empty responses; the model substituted in for A7 was fixed as GPT-3.5-Turbo.
Main results
Attack containment rates (mean over 5 models × 5 phrasings × 3 repetitions, per Table I; some columns for A12–A14 are filled values):
Swipe horizontally to read the table
Scenario Base +Id +Tr +At +Po A1 external attacker 20 100 100 100 100 A4 stolen certificate 53 56 100 100 100 A5 replay attack 15 13 17 15 75 A6 prompt injection 51 53 52 52 52 A7 model substitution 0 0 0 100 100 A9 unauthorized delegation 15 19 13 16 71 A10 supply chain 37 37 93 100 100 Overall (14 scenarios) 43 49 61 76 84 (Rows for A2, A3, A8, A11, A12, A13, and A14 are omitted; among them, A3's baseline of 96% is the highest baseline, and A11 is only 32% with all planes enabled.)
- The authors state that each plane blocked the scenarios it targets: Identity blocks A1, Trust blocks A4, A10, A12, A13, Attestation blocks A7, A8, A14, and Policy improves A5 and A9; results for scenarios fully targeted by a plane no longer depend on model or phrasing.
- The authors treat the 10–25 percentage point fluctuations in non-targeted scenarios (e.g., A2 from 44 to 61, A3 from 96 down to 81) as the noise level of that table; A5 and A9 stop in the seventies, and the authors state that the rules trigger only on matching tool calls, with some models omitting the transaction ID in writes.
- The authors note that some attacks were already refused by the models' own safety training with no defense (A3 baseline 96%, A8 baseline 79%), and that differences across models are large: A6 containment rate 0% on two models and 93% on another, so single-model evaluation would misjudge system safety.
Utility retention
- Six benign tasks were run 15 trials each under no defense and full ATI: success rate 91% vs 92% (Table II); B3 and B6 each had one fewer success, B4 and B5 each had one more, which the authors describe as normal fluctuation under 15 trials.
- B3 (reading data from two offices) is flagged by audit by design but not rejected.
Cross-framework interoperability and overhead
- One benign front-door task was run once on each of the six frameworks (GPT-4o-mini, scored by an earlier three-judge panel), and all returned correct results; the authors explicitly state that this does not show agents behave consistently on every framework, and that the 14 attack scenarios were not repeated on the other four frameworks, so "running all scenarios on all six frameworks remains to be done."
- Overhead (Table III, mean of 5000 repetitions on a single laptop): Identity+Trust entry check 151.0 µs, Attestation 0.2 µs, Policy+log append 23.7 µs, full chain about 173.8 µs per request (about 191 µs on a rerun on the same machine); the authors state this is about 0.02% of a one-second model call, but throughput under high load or with thousands of agents was not measured.
Accountability and audit tests
- Under clean runs the hash chain verifies; modifying an entry's identity, model, timestamp, tool or parameter hash, or forging a signature is detected at that entry; deleting an entry from the end is not detected, because there is no record of the chain's expected length.
- A11 collusion patterns are flagged by the log's separation-of-duties (detection rather than blocking), so A11 shows no improvement in Table I, which the authors state is as expected.
Other ablations and analysis
- A10 is 93% rather than 100% at the Trust step: on Llama-3.1-8B, 4 trials had no judge verdict and were counted as not blocked, and 1 more was judged not blocked.
- A12 (expired certificate) baseline 54%, 100% after Trust; A13 (cross-organizational CA) baseline 75%, 100% after name constraint checking; A14 (system prompt tampering) baseline 27%, 100% after Attestation.
- Fig. 9 shows a single run of A9 on GPT-4o-mini: with no defense, Org 2 saved a modification requested by another organization; with ATI enabled, the Policy plane rejects at the db_write call; the authors state this is only a single run illustrating the mechanism, and rates are per Table I.
What are some points that can be further explored?
The authors list design limitations including prompt injection, collusion, detection of stolen private keys, and privacy controls; experiments were conducted in a single-process simulation and on two frameworks.
Limitations and future directions noted by the authors
- Prompt injection and collusion unresolved (Section VIII): A6 exploits untrusted content processed by the agent, which the existing trust planes do not directly defend against; A11 collusion is indistinguishable from legitimate cross-organizational collaboration behavior, and deterministic access control rules are difficult to prevent.
- Stolen private keys cannot be independently detected (Section VIII): recovery depends on certificate revocation and reissuance, and recovery latency was not experimentally evaluated.
- Privacy controls missing (Section VIII): certificates and audit logs may expose organizational relationships and communication patterns; sensitive scenarios require data minimization and privacy-preserving logging mechanisms beyond the current Policy plane.
- Attestation relies on host self-reporting (Sections VI, VIII): Attestation runs in the same process as the agent and cannot guarantee protection against attackers who control the underlying host; hardware-backed attestation (TPM/TEE) could strengthen this but is not implemented.
- Deletion at the end of the log is undetectable, and stolen signing keys can forge history (Section VIII): the current design provides tamper-evident records under the assumption that signing keys are secure, rather than unconditional non-repudiation; external log anchoring, independent witnesses, or hardware-protected keys could strengthen this.
- Future directions (Section IX): standardizing AI-specific identity and attestation attributes (model provenance, execution framework, tool permissions, delegated authorization), interoperable federation member discovery, distributed revocation mechanisms, and production-scale evaluation involving independent administrative organizations; Section VII also mentions restricting the fields each office can return to partially address A2, left for future work.
Scope of experimental coverage
- 5 agent models were tested: GPT-4o-mini, Claude 3 Haiku, DeepSeek-Chat, Qwen2.5-7B, Llama-3.1-8B; the model substituted in for A7 was fixed as GPT-3.5-Turbo.
- Containment and utility experiments used only two organizations (CrewAI and AutoGen frameworks); the other four frameworks each ran only one benign task, and attack scenarios were not repeated on them.
- The entire federation was simulated within a single process: signatures did not traverse the network, Attestation was checked only once when a request entered the federation, and all organizations shared one log; the claim that "a certificate without the private key cannot forge signatures" was not measured.
- 75 trials per attack scenario (72 for A12 and A13, 67 for A14), 15 trials per benign task; four of the five judge models were also the tested models, and the authors note that judging was not fully independent.
- The paper does not report throughput under high load or with large numbers of agents; overhead data come from a single benchmark run on a single laptop (5000 repetitions).
Summarize the main content of the paper
ATI provides identity, trust, attestation, authorization, and accountability for cross-organizational agents through a five-plane reference monitor outside the model; in simulated evaluation, containment rose from 43% to 84%.
A defense paper: addressing the lack of verifiable identity, execution integrity, and authorization mechanisms for cross-organizational autonomous AI agents, it proposes Agent Trust Infrastructure (ATI), which places security checks in a reference monitor outside the agent model and framework.
- Method: five planes — Identity (Ed25519 keys, AID as the public key hash), Trust (each organization's AgentCA forming a rootless flat federation, verifying certificate issuer, validity period, revocation, and name constraints), Attestation (verifying hashes of the running model, fixed tools, and system prompt), Policy (three rules checked on each tool call: cross-organizational writes, replay, bulk export), Accountability (signed hash-chain logs, record-only without blocking, flagging collusion patterns). Implemented as an open-source package of about 350 lines of Python, using IETF WIMSE tokens and the Entity Attestation Token format.
- Main results: In an eight-organization simulated federation, five agent models, and 14 attack scenarios, overall containment rose from 43% with no defense to 84% with all four planes enabled (Table I); scenarios targeted by a plane (A1, A4, A7, A8, A12–A14) all reached 100%, and A5 and A9 partially improved to 75%/71%.
- Cost: benign task success rate 91% (no defense) vs 92% (full ATI); per-request check overhead about 174 µs.
- Cross-model finding: the authors state that the same attack yields widely different results across models (A6 containment rate 0% on two models and 93% on another), so single-model evaluation would misjudge safety, whereas ATI's deterministic entry checks blocked the attacks they target in nearly all trials.
- Unresolved: prompt injection (A6, 52% with all planes enabled) and collusion (A11, detection only) are largely not blocked; the authors conclude that model-layer safety behavior is insufficient to provide consistent security enforcement, that deterministic checks provide model-agnostic protection, but that attacks remain when malicious actions are indistinguishable from legitimate operations.