Agent Trust Infrastructure: Federated Identity and Attestation for Cross-Organization AI Agents A developer built Agent Trust Infrastructure (ATI), a framework-independent security layer that uses PKI, Zero Trust Architecture and remote attestation to establish federated trust between AI agents across organizations without a shared root authority. In a simulated federation of eight organizations running five-agent teams across six frameworks, ATI raised attack containment from 43% to 84% across 14 attack scenarios at roughly 174 microseconds of overhead per request, mostly from attestation verification. When an agent from your organization invokes a tool hosted by another company's agent, how do you verify that agent's identity, check its execution integrity, and enforce authorization policies? Most agent frameworks punt on this question. They assume trust within a single organization's boundary and leave cross-organizational collaboration as an exercise for the reader. Agent Trust Infrastructure ATI fills that gap. It's a framework-independent security layer that uses PKI, Zero Trust Architecture, and remote attestation to establish federated trust between organizations without requiring a shared root authority. Each organization runs its own certificate authority AgentCA , and agents prove their identity, model configuration, tool access, and system prompt before executing requests across organizational boundaries. Current agent frameworks handle planning, tool invocation, and coordination within a single trust domain. They do not address: ATI treats these as infrastructure problems. It sits outside the agent framework as an external enforcement layer, validating requests before they reach the agent's execution environment. ATI has four core pieces: Organizations federate by exchanging AgentCA public keys. No shared root authority is required. Each organization decides which other organizations it trusts and under what conditions. Here's what happens when Agent A from Org X invokes a tool hosted by Agent B from Org Y : The attestation step is the critical piece. It prevents an attacker from presenting a valid certificate while running a different model or modified tools. The attestation service compares runtime state model weights, tool code, prompt text against the hashes in the certificate. ATI enforces three policy layers: | Policy Type | Check | Failure Mode | |---|---|---| | Certificate validation | Is the certificate signed by a trusted AgentCA? Is it expired? | Reject request, log unauthorized access attempt | | Attestation verification | Does runtime state match certificate claims? | Reject request, log integrity violation | | Authorization | Does the requesting agent have permission for this tool? | Reject request, log policy violation | Each layer is independent. You can disable attestation for performance reasons at the cost of integrity guarantees or tighten authorization policies without changing certificate issuance. ATI integrates with existing agent frameworks without modifying their models or orchestration logic. It runs as a sidecar or gateway that intercepts requests before they reach the agent. The paper evaluates ATI in a simulated federation of eight organizations, each running a five-agent team across six different frameworks LangChain, AutoGPT, Semantic Kernel, etc. . The evaluation includes 14 attack scenarios: stolen certificates, model substitution, prompt injection, tool tampering, and replay attacks. With all enforcement mechanisms enabled, attack containment increases from 43% to 84%. The cost is approximately 174 microseconds of overhead per request. Most of that overhead comes from attestation verification. Certificate validation and policy checks add negligible latency. Remote attestation is the hardest part to implement. The attestation service needs to: This requires access to the agent's runtime environment. In practice, you run the attestation service on the same host as the agent and use platform-specific attestation APIs TPM on bare metal, vTPM in VMs, enclave attestation in confidential compute . For containerized agents, you can use image digests as a proxy for model and tool integrity. The attestation service verifies that the running container matches the digest in the certificate. This is less precise it doesn't catch in-memory modifications but easier to deploy. Every cross-organizational request generates an audit log entry with: For multi-hop collaborations Agent A calls Agent B, which calls Agent C , the audit log includes the full chain. Each agent appends its identity to the request context, so the final log entry shows the complete provenance. This is critical for accountability. If an agent misbehaves, you can trace the request back to the originating organization and agent. ATI assumes that AgentCAs are trustworthy. If an organization's AgentCA is compromised, an attacker can issue valid certificates for malicious agents. The federated model limits blast radius only organizations that trust the compromised AgentCA are affected , but there's no automatic revocation mechanism. Attestation depends on platform security. If an attacker has root access to the agent's host, they can forge attestation reports. ATI mitigates this with remote attestation using hardware roots of trust like TPMs , but not all deployment environments support this. Authorization policies are static. If an agent's permissions need to change mid-task, you must reissue its certificate. Dynamic policy updates would require a separate policy distribution mechanism. ATI adds operational complexity. Each organization must: For small-scale deployments a few organizations, a few agents , this overhead may not be worth it. For large-scale federations dozens of organizations, hundreds of agents , the security and accountability benefits justify the cost. The 174-microsecond overhead is negligible for most agent workloads. If you're invoking tools that take seconds to execute, adding 0.2 milliseconds for security checks is a rounding error. If you're building a high-frequency trading agent that makes thousands of tool calls per second, you'll feel the latency. Use ATI when: Avoid ATI when: ATI is infrastructure for a future where agents routinely cross organizational boundaries. If you're building that future today, this is the plumbing you need. If you're not, it's overkill.