AdSourcing

AdSourcing lets AI agents negotiate community sponsorships, lock payment in escrow, verify delivery proof, and generate auditable payment receipts.

Comment

Inspiration

Small community sponsorships are still too manual.

A brand that wants to sponsor a Discord or Telegram community has to find the right community, ask for rates, negotiate terms, check content safety, handle payment, verify delivery, and keep proof manually. That process is too expensive for small deals, so many potential micro-sponsorships never happen.

AdSourcing was built around one question: what if sponsorship could be executed by accountable AI agents, not by endless manual negotiation?

What it does

AdSourcing is an agentic sponsorship protocol for creator and community advertising.

It has two main agents:

  • SponsorAgent represents a brand or sponsor.
  • CommunityAgent represents a Discord or Telegram community.

The SponsorAgent receives a mandate such as budget, max price per post, content policy, audience requirement, wallet authority, and sponsor-side top-up evidence. The CommunityAgent receives a mandate such as price floor, content rules, delivery channel, sponsor reputation threshold, and payout wallet.

After setup, both agents run the sponsorship flow:

  1. Sponsor creates or attaches a DOKU Sandbox top-up invoice as prefund evidence for the buying mandate.
  2. SponsorAgent broadcasts sponsorship intent.
  3. CommunityAgent verifies identity, signature freshness, wallet binding, reputation, prior memory, and inventory.
  4. Both agents negotiate inside strict policy limits.
  5. SponsorAgent locks payment in local USDC escrow.
  6. CommunityAgent delivers the sponsored post to Discord.
  7. SponsorAgent verifies the Discord delivery proof.
  8. Payment is settled and a receipt/proof bundle is generated.
  9. The completed deal is stored as agent memory for future risk and pricing decisions.

The important distinction is that DOKU is used as the sponsor-side fiat top-up / checkout layer in this hackathon demo. It does not auto-convert fiat into USDC and does not directly settle the community payout. The accountable settlement path in the demo is handled by local USDC escrow and proof-based payment receipts.

How we built it

We built AdSourcing as a TypeScript-based multi-agent system with smart contract rails, agent memory, payment evidence, and a dashboard for demo clarity.

The system includes:

  • SponsorAgent and CommunityAgent services.
  • ERC-8004-style identity and reputation checks.
  • Signed mandates, offers, and agent decisions.
  • Solidity contracts for intent registry, MockUSDC, and escrow.
  • Hardhat local chain support for deterministic demo runs.
  • DOKU Sandbox support as a sponsor-side fiat top-up / checkout extension.
  • Local USDC escrow for proof-based settlement in the demo.
  • Real Discord delivery support for sponsored post delivery.
  • Delivery proof verification using Discord message IDs.
  • Proof bundle and payment receipt generation.
  • Agent memory for mandates, prior deals, receipts, and counterparty history.
  • Mem9 integration for storing settled sponsorship memories and recalling prior counterparty context.
  • OpenClaw bridge and plugin tools for agent orchestration.
  • A browser dashboard that visualizes the sponsorship lifecycle.

The core payment path uses escrow: payment is locked before delivery and released after proof. DOKU Sandbox is used as sponsor-side prefund evidence, while the accountable settlement rail in the demo is the local USDC escrow and receipt system.

The memory layer helps the agents avoid treating every counterparty as brand new forever. Locally, each agent stores mandates, receipts, and deal history. When Mem9 is configured, settled sponsorship outcomes are written as long-term memories, including proof hash, payment receipt, delivery proof, wallets, and deal terms. This allows agents to recall prior counterparties and use previous outcomes as risk or pricing signals for future sponsorships.

Challenges we ran into

The hardest part was making the demo feel like a real product while still showing enough technical depth for a hackathon.

A simple dashboard was not enough. Judges need to understand that the agents are the product, not just the UI. So we redesigned the dashboard around the actual agent workflow: prefund, identity, negotiation, escrow, Discord delivery proof, payment receipt, and memory.

Another challenge was keeping the AI layer bounded. We did not want an LLM that only recommends actions. We wanted agents that can act, but only inside deterministic limits. Budget checks, content policy, reputation thresholds, memory signals, and escrow conditions are enforced before important actions happen.

We also had to be careful with payment claims. The demo uses local USDC escrow and proof-based settlement as the core accountable payment rail, while DOKU Sandbox is included as a sponsor-side fiat top-up / checkout extension. Production DOKU settlement would require proper merchant verification, webhook enforcement, and a production payout design.

Discord delivery also introduced real integration complexity. We had to separate local delivery from real Discord delivery, validate bot credentials on VPS, post sponsored content to a real channel, and verify the Discord message ID as delivery proof.

Finally, agent memory required careful framing. Memory is useful for future trust, pricing, and risk decisions, but it should not replace deterministic policy checks. Prior deal memory can inform the agent, while policy gates still decide whether an action is allowed.

Accomplishments that we're proud of

We are proud that AdSourcing is not just a chatbot demo.

The system can run an end-to-end sponsorship loop:

  • create agent mandates;
  • attach DOKU Sandbox top-up evidence to the sponsor mandate;
  • verify counterparty identity and reputation;
  • recall prior deal context through local memory and optional Mem9 memory;
  • negotiate inside policy limits;
  • reject unsafe sponsorship before escrow;
  • lock payment in local USDC escrow;
  • post the sponsored content to Discord;
  • record Discord delivery proof;
  • settle payment after proof;
  • generate payment receipts and proof bundles;
  • store completed deal outcomes as agent memory.

We also built an OpenClaw integration so the same protocol can be called through agent tools, not only through the dashboard.

The bad-case flow is especially important: unsafe sponsorship content is rejected before payment moves. That makes the payment use case safer and more realistic.

We are also proud of the memory layer. Completed sponsorship outcomes can become future agent context, so repeat counterparties, prior receipts, disputes, and successful deals can influence future risk and pricing decisions.

What we learned

We learned that agentic commerce needs more than model reasoning. It needs identity, delegated authority, policy boundaries, payment rails, proof, receipts, and memory.

The most important design decision was separating the AI layer from the enforcement layer. The LLM can help interpret user intent, but the protocol decides whether an action is allowed.

We also learned that payment-related agent systems must be honest about settlement. In our demo, DOKU Sandbox provides sponsor-side top-up evidence, while local USDC escrow provides the accountable settlement path. Those two layers solve different parts of the payment story.

We learned that agent memory is important for commerce. A sponsorship agent should not treat every counterparty as brand new forever. By storing completed deals, proof hashes, receipts, and past outcomes, agents can make better future decisions about pricing, risk, and trust.

We also learned that auditability matters as much as automation. A good agent should not only act; it should leave behind evidence that explains why it acted.

What's next for AdSourcing

Next, we want to harden AdSourcing into a production-ready agentic sponsorship network.

Planned improvements include:

  • production deployment of the protocol contracts;
  • public testnet or mainnet ERC-8004 identity and reputation integration;
  • real merchant onboarding flow for the DOKU payment gateway path;
  • DOKU payment confirmation and webhook enforcement before agent spending;
  • production design for fiat-to-escrow or fiat-backed agent balances;
  • stronger Mem9-based memory recall for repeat counterparties and risk scoring;
  • hosted agent cards and public agent discovery;
  • real Discord and Telegram community onboarding;
  • dispute handling for failed or low-quality delivery;
  • better analytics for sponsors and community owners;
  • secure wallet custody and permission management;
  • security review for payment settlement, agent authority, and memory trust boundaries.

The long-term vision is a network where trusted AI agents can source, negotiate, pay, verify, remember, and repeat small sponsorship deals across communities.

Built With

Share this project:

Updates