Inspiration
We were inspired by the idea that AI agents will eventually be able to act on our behalf—making purchases, accessing services, and communicating with other agents without a human involved in every step. But if agents are going to operate autonomously, we need a way to know who an agent is, whether it can be trusted, and whether a request actually came from that agent.
That led us to build a system where two AI agents can securely communicate and transact with each other rather than simply trusting an incoming connection.
What We Built
We created two agents: a Buyer and a Supplier. The Buyer can discover and communicate with the Supplier, verify its identity and trust credentials, authorize a purchase, and validate that the transaction is coming from the legitimate agent.
We implemented multiple security layers, including cryptographic identities, proof-of-possession, mutual trust verification, payment authorization, and request validation. The goal was to make agent-to-agent commerce verifiable instead of relying on implicit trust.
How We Built It
We built the project as a collection of services running on a cloud VM, with the agents communicating through secured endpoints. We used agent identity and trust mechanisms to establish a verified relationship between the Buyer and Supplier.
For a purchase, the Buyer performs multiple checks before accepting the Supplier. Requests include cryptographic proofs that allow the receiving side to verify that they came from the expected agent and were not simply fabricated by an attacker.
We also built testing around the system to verify the different rejection conditions and security checks. By the end, our test suite had 110 passing tests.
What We Learned
The biggest thing we learned was that securing AI agents is more complicated than simply putting authentication in front of an API. An agent needs an identity, but the other agent also needs to determine whether that identity is trustworthy and whether the specific action being requested is actually authorized.
We also learned how different security mechanisms can work together. Identity, trust, authorization, and proof-of-possession each solve different problems, and combining them creates a much stronger system than relying on any single mechanism.
Challenges
One of our biggest challenges was getting the infrastructure and identity system working reliably. DNS, certificates, agent registration, trust relationships, and the services themselves all had to work together correctly.
Another challenge was making sure that a legitimate request could pass through every security layer while invalid or unauthorized requests were rejected for the correct reason. Debugging these interactions required extensive testing and careful verification.
We also had to balance our time between building the security infrastructure and creating the user interface. Our UI is still relatively basic because we prioritized securing the underlying agent connection first. We wanted to prove that the difficult security foundation actually worked before spending significant time polishing the interface.
What's Next
Our next step is to build a more polished interface around the security infrastructure we've already created. We also want to integrate the system with a real product or transaction workflow rather than our current simulated settlement.
Ultimately, we want this project to provide a foundation for a world where AI agents can safely discover, authenticate, trust, and transact with other agents without requiring humans to manually verify every interaction.
Log in or sign up for Devpost to join the conversation.