Inspiration
AI agents are becoming capable of researching, planning, and executing increasingly complex tasks, but payments are still usually treated as a separate step that requires a human to approve a transaction.
We built PayLabs around a different idea: payments should be part of the agent's execution environment.
An agent should be able to decide which services it needs, operate within a predefined budget, pay for those services autonomously, track why each payment happened, and distribute value back to the creators whose content contributed to the final result.
That led us to build PayLabs as an autonomous agent economy for AI-powered source discovery and creator monetization.
Instead of simply consuming information from the web, PayLabs creates an economic relationship between the agent, the services it uses, and the creators whose sources provide value.
What it does
PayLabs is an autonomous multi-agent system where AI agents discover information, coordinate specialized services, execute x402 nanopayments, and automatically distribute USDC to verified creators.
A user submits a research query and the PayLabs Brain creates an execution plan.
From there, the system can:
- determine the appropriate execution strategy,
- allocate a budget,
- activate specialized agent services,
- discover and evaluate sources,
- execute x402 service payments,
- verify source ownership,
- determine creator attribution,
- calculate value allocation,
- and distribute USDC to eligible creators.
Payments are not an additional checkout step. They are embedded directly into the agent execution graph.
Every payment produces traceable receipt metadata so users can inspect what was paid, why it was paid, and how the execution progressed.
PayLabs currently runs live on Arc Testnet and processes real testnet USDC payments through Circle infrastructure.
How we built it
PayLabs separates AI reasoning from financial authority.
The high-level planning layer is implemented as a LangGraph-based Brain Planner. It determines the search strategy, execution tier, and services required for a task.
Below the planner is a deterministic TypeScript runtime responsible for financial execution.
The runtime controls:
- budgets,
- service pricing,
- wallet selection,
- payment references,
- x402 execution,
- creator attribution,
- settlement,
- and receipt generation.
This separation is intentional.
The LLM is allowed to reason about what should happen, but it cannot arbitrarily move money. Financial actions must pass through deterministic policies and execution rules.
Agent execution flow
User Query
↓
PayLabs Brain
↓
Execution Plan + Budget
↓
Discovery Agents
↓
Source Evaluation
↓
Payment Decision
↓
x402 Service Payments
↓
Creator Attribution
↓
USDC Creator Payout
↓
Receipts + Payment Proof
For the payment layer, PayLabs integrates Circle infrastructure including:
- Circle Developer Controlled Wallets
- Circle User Controlled Wallets
- Circle Gateway
- x402 nanopayments
- USDC
- Arc Testnet
Users receive a PayLabs wallet used for agent execution, while creators use a separate wallet for source identity, ownership verification, and monetization.
Agent-native payments
One of the most important design decisions was making payments part of the agent graph itself.
PayLabs contains multiple payment edges between the Brain, macro execution phases, and individual agent services.
An execution may include payments for:
Brain
↓
Discovery Phase
↓
Search / Signal Services
Brain
↓
Payment Decision Phase
↓
Verification / Attribution Services
Brain
↓
Settlement Phase
↓
Creator Payout
These payments are executed programmatically rather than through a human checkout flow.
Circle Gateway can batch multiple x402 payment edges into settlement transactions, reducing the number of individual onchain transactions while preserving the economic relationships between agents and services.
Payment transparency
Agent payments become difficult to understand once a workflow contains many autonomous services.
Because of that, we built a receipt and explorer layer specifically for PayLabs.
The system records payment metadata such as:
- payer,
- recipient,
- amount,
- service,
- payment reference,
- settlement information,
- transaction proof,
- and the reason the payment occurred.
We also implemented the x402 HTTP challenge and payment-signature flow at a lower level instead of relying entirely on a high-level wrapper.
This allows PayLabs to capture the payment and settlement information needed to trace individual agent payment edges and connect them to their corresponding settlement proofs.
The result is a visible execution history where users can follow the money through the agent system instead of treating autonomous payments as a black box.
Creator monetization
PayLabs also explores what happens when AI consumption directly produces payments for information providers.
Creators can register sources such as:
- GitHub repositories,
- blogs,
- websites,
- and other online resources.
They then verify ownership of those sources.
When PayLabs uses an eligible source during an execution, the system can attribute value to that source and automatically route a USDC payout to its verified creator.
This creates a simple economic loop:
Creator publishes useful information
↓
Agent discovers the source
↓
Source contributes to an answer
↓
PayLabs evaluates attribution
↓
Creator receives USDC
Our goal is to explore an internet where autonomous agents do not only consume APIs and information, but can also compensate the services and creators that provide value.
Challenges we faced
Making autonomous payments observable
Batching is efficient, but it makes individual payment relationships harder to understand from a normal block explorer.
A single settlement transaction can represent multiple underlying agent payments.
We built custom decoding, payment-linking, receipts, and explorer interfaces so users can inspect individual payment edges while still benefiting from batched settlement.
Separating reasoning from financial control
Giving an LLM unrestricted wallet authority would create unnecessary risk.
We therefore designed PayLabs so the Brain proposes execution decisions while deterministic controllers enforce pricing, budgets, wallet usage, settlement rules, and payment destinations.
This gives the system useful autonomy without making financial behavior entirely dependent on probabilistic model output.
Coordinating multiple autonomous services
A multi-agent payment system introduces more than orchestration complexity.
Every service invocation can also become an economic event.
We had to coordinate execution state, budgets, payment references, service responses, settlement state, and receipt generation while keeping the final experience understandable to the user.
Creator attribution
Paying a creator is easy.
Determining whether a creator should be paid, whether they actually own a source, and how much value that source contributed is much harder.
PayLabs therefore separates source verification, attribution, value allocation, and payout routing into distinct stages.
What we learned
The largest lesson from building PayLabs is that autonomous payments cannot simply be added to an AI application at the end.
Once agents can spend money, payment state becomes part of application state.
Budgets, permissions, receipts, settlement status, service identity, and transaction proofs all become part of the agent's execution model.
We also learned that autonomy benefits from clear separation of responsibilities:
- LLMs are useful for reasoning and planning.
- deterministic systems are better for enforcing financial constraints.
- wallets provide execution authority.
- payment protocols provide economic coordination.
- receipts provide accountability.
Combining those components creates a much stronger architecture than allowing an AI model to directly control every financial decision.
Current traction
PayLabs is live and has been actively used on Arc Testnet.
The platform has processed:
- 3,000+ x402 service payments
- 500+ execution receipts
- 50+ users and testers
These executions use real testnet payment infrastructure rather than simulated payment events.
What's next
Our next step is expanding PayLabs from a closed collection of internal agent services into a broader agent economy.
We want agents to dynamically discover external paid services, evaluate their value, purchase them within predefined spending policies, and incorporate the results into larger autonomous workflows.
We also want to continue improving creator attribution so AI-generated economic activity can automatically compensate the humans and services providing the underlying information.
The long-term goal for PayLabs is simple:
Agents should be able to reason about value, spend within clearly defined rules, and automatically pay the participants that make their work possible.
Built With
- arctestnet
- circledevelopercontrolledwallet
- circleusercontrolledwallet
- langchain
- langgraph
- react
- rsshub
- usdc
- vercel
- x402
Log in or sign up for Devpost to join the conversation.