The problem it solves

At​‍​‌‍​‍‌ the moment

AI agents are like lonely geniuses locked up in solitary confinement. Although they have massive processing power, they are practically powerless in the market. If an autonomous agent wants to use an external tool, for example, a specialized image generator or a premium market data feed, it just cannot do that. The agent can only make up a request or error out until a human physically inserts a credit card, creates an API key, and hardcodes it into a .env file.

ASAP (Agent Service Discovery & Attestation Protocol) fixes the "Agent Cold Start" issue. It converts agents from isolated chatbots into autonomous economic actors.

This protocol which I have constructed is supposed to be two essential layers of infrastructure for the machine economy:

• The "Yellow Pages" (Discovery): A decentralized, on-chain registry where agents can programmatically search for services based on capabilities and trust (via Farcaster attestations), instead of depending on static, human-curated lists or centralized DNS.

• The "Visa Network" (Settlement): A real-world usage of the long-dormant HTTP 402 (Payment Required) standard. It permits agents to perform negotiations and settle payments for API access instantly and on a per-request basis, without human intervention.

Real-World Utility:

• Autonomous Supply Chains: A "Manager Agent" is able to on the fly recruit a "Coder Agent" and a "Designer Agent" from the registry, pay them in $ASAP tokens, and complete a product without the user having accounts on three different SaaS platforms.

• DePIN Monetization: Those who have powerful local hardware (e.g., a gaming PC running Llama-3) can turn their IP into an endpoint. Agents everywhere can find this endpoint and pay micro-transactions to execute inference tasks, thus allowing the compute access to be democratized.

• Permissionless Access: In contrast to OAuth or Stripe, which need KYC and passports, ASAP permits any script with a private key to take part in the economy.

To sum it up, I have set up the infrastructure whereby a Python script(An Autonomous Bot) can employ a Netlify function(Endpoint) and pay for it with Crypto($ASAP Tokens), all without human ​‍​‌‍​‍‌intervention.

Challenges we ran into

It's​‍​‌‍​‍‌ almost never about just writing the happy path when one wants to build decentralized infrastructure; rather, it is about dealing with the mess that comes from chaos of distributed systems. Here are the obstacles in detail that I managed to overcome:

1. The "Free Tier" RPC Bottleneck: In the very beginning, I conceived the Indexer to be the normal enterprise service kind of the Indexer—meaning that it would carry out the entire blockchain history at startup so the database could be built locally. Public RPC nodes, of course, were the first to limit the rate of my requests when I tried to fetch data for 100,000 blocks in one go. The indexing logic thus had to be re-architected by me in order to implement a "chunking" method that breaks block ranges into digestible 2,000-block segments with exponential backoff. It is a less aggressive method, but it is what keeps the indexer stable on free-tier infrastructure.

2. The "Unknown Agent" Race Condition: To save gas on Base Sepolia, I made the smart contracts more efficient so that they would emit only the minimal data in events (IDs and pointers). Nonetheless, this led to a race condition in the frontend whereby the UI would render "Unknown Agent" as the event log did not have the human-readable name. The Indexer was rewritten by me to be a "Smart Poller"—it now gets the event, makes a secondary readContract call to get the full JSON metadata from the chain, and after verification, it commits to the local SQLite database. The frontend communicates with the Indexer only, thus partial state is never shown.

3. Reactivity vs. Blockchain Latency: The hit of humility that comes from seeing a user clicking on "Pay," viewing the transaction confirmation on the blockchain, and on seeing the UI balance not changing and still showing 0 can hardly be matched by anything else. The very cause of the UI confusion was that the disconnect between the blockchain's "confirmed" state and the RPC node's "indexed" state was leading to the UI showing old data. I addressed this issue by the introduction of an aggressive cache invalidation strategy with the use of TanStack Query. I set a refetchInterval on the wallet balance and a manual invalidation was triggered 1.5 seconds after transaction receipt—a "network buffer" that was absolutely necessary for the delay in the propagation of the testnet.

4. The snake_case Python Migration:: While working on the autonomous Python bot, a moment came when the script kept crashing during transaction signing, and I couldn't figure out why. The reason being, I was following the web3.py v5 guide for the docs, but the environment had v6 installed, which changed the naming convention from camelCase to snake_case for nearly all attributes (e.g., rawTransaction became raw_transaction). It was a small syntax mistake that was pointing to a major cryptographic failure and as a result, it taught me the lesson that I should always pin my dependencies.

5. Simulation vs. Reality:: My first frontend demo was just "spoofing" the 402 error to demonstrate how it would look. I wasn't satisfied with that. At the hackathon's midpoint, I decided to go in a completely different direction and actually create a serverless Oracle on Netlify that verifies transaction hashes on-chain. To connect the frontend to this real endpoint, the TestAgentModal had to be rewritten so that it could dynamically deal with the real HTTP 402 responses, getting the payment details by parsing the JSON body rather than from the hardcoding. The end result is a frontend that does a cryptographic handshake for real, not just a UI ​‍​‌‍​‍‌animation.