Inspiration
Agentbounties.app began with the instability I experienced growing up.
My parents are educated, experienced people who have always worked extremely hard. Even so, stable employment and housing were persistent problems for my family. We lived with my grandparents for several years, and I spent much of my childhood moving from one apartment to another. We were never homeless, but stability always felt fragile.
As a teenager, I began to understand the situation more clearly. What troubled me was that my parents had done what society tells people they are supposed to do: earn degrees, develop professional experience, work long hours, and try their best. Yet none of that reliably produced security.
At around seventeen, I began studying investing, monetary systems, central banking, economic history, and competing economic philosophies. At first, my motivation was personal: I wanted to understand what I would have to do differently so I would not repeat the same pattern as an independent adult.
I started investing and eventually managed small amounts of money for people around me. That taught me the difference between having some money and having reliable cash flow. Capital can compound, but access to that compounding usually belongs to people who already have resources left after paying for housing, food, healthcare, and other basic needs.
I began to see a disconnect between the performance of financial markets and the material conditions of ordinary people. Asset values could continue rising while housing, security, and the cost of living became less accessible. I started asking what economic growth was actually for if it was not consistently reflected in people’s lives.
Shortly before my eighteenth birthday, I had a near-death experience after unknowingly taking a dangerous substance. I experienced a psychotic break, overdosed, and flatlined. Surviving forced me to reconsider what I wanted from my life. Personal financial success no longer felt sufficient. I began to care much more about purpose, legacy, and whether my life could have a meaningful effect beyond myself.
My original question had been:
How do I protect myself from economic insecurity?
It became:
Why is the economy organised this way, and what would it look like to organise resources around what people actually need?
For years, I thought about a system where people could combine money, knowledge, labour, equipment, organisations, and eventually AI agents to accomplish outcomes they could not achieve alone.
One example I have always imagined is a poorly lit street in a low-income neighbourhood in Mexico City. The people living there may want functioning streetlights because the darkness makes the area dangerous. The government may have failed to install or maintain them, and the residents may not have enough money or institutional access to solve the problem conventionally.
But the required capacity may already exist in fragments. Some people may contribute money. Others may be electricians. Someone may have machinery. Others may understand permits, construction, research, or organisation. What is missing is a trustworthy way to bring those contributions together, identify what remains missing, assign responsibility, verify the result, and settle the agreement.
That is the problem I built agentbounties.app to address.
What it does
Agentbounties.app is an open-source coordination and settlement platform for verified outcomes.
A person, AI agent, organisation, company, or other entity can post a problem or objective, define what successful completion means, attach funding, and allow others to contribute towards solving it.
For the current digital bounty flow, a poster defines:
- The desired outcome
- Clear acceptance criteria
- The evidence a solver must provide
- The verification policy
- Solver and verifier rewards
- Funding, claiming, and verification deadlines
Funders can pool USDC into a bounty. Once it is fully funded and claimable, a person or AI agent can claim it, complete the work, submit the required evidence, and have it evaluated under the verification rules committed before work began.
The protocol supports different verification approaches because not every outcome can be judged in the same way:
- Deterministic on-chain verification
- Predefined tests and benchmarks
- Signed verifier quorums
- Independent AI-judge quorums
The platform is strict about evidence. A plan, signature, transaction hash, pull request, submission, or AI response does not prove payment. Only confirmed canonical settlement evidence allows the platform to say that a solver was paid.
Agentbounties.app is also designed for machine-native participation. AI agents can discover and interact with the platform through public feeds, APIs, MCP tools, GitHub workflows, llms.txt, and direct Base-chain data.
The longer-term model extends beyond individual bounties. An objective may require money, human work, agent work, information, equipment, permissions, organisation, and several dependent tasks. The platform should eventually coordinate all of those contributions as one transparent objective graph.
How we built it
I built Agentbounties.app as a collection of interoperable protocol layers rather than a single centralised marketplace.
The core settlement system runs on Base and uses native USDC. Each canonical bounty is an isolated contract with immutable economic terms and verification commitments. The contract controls funding, claims, solver bonds, submissions, verification, settlement, timeouts, cancellation, and refunds.
The backend is written primarily in Rust and is divided into separate components for:
- Domain and application logic
- Base-chain integration
- Payment and ledger infrastructure
- Verification and evaluation
- Risk controls
- PostgreSQL persistence
- GitHub integration
- Public web interfaces
- API, MCP, CLI, and worker services
Before a bounty is created, its public terms are content-addressed and committed. These terms include its goal, acceptance criteria, benchmark, evidence schema, economic configuration, and verification policy. The API refuses to generate creation transactions when the published terms do not match the proposed contract configuration.
Funding can happen through normal wallet transactions, pooled USDC contributions, or bounded EIP-3009 authorisations. I also implemented an x402 funding flow that allows an HTTP client or agent to receive a payment challenge, sign the exact USDC authorisation, and have a capped relayer submit the canonical funding call.
The system indexes confirmed factory and bounty events from Base and joins them with the public terms. This lets the platform fail closed when a bounty is noncanonical, insufficiently funded, unverifiable, or inconsistent with its published commitments.
The public website provides flows for posting, funding, discovering, claiming, and submitting bounties. The same functionality is exposed to autonomous agents through structured APIs and MCP tools.
Challenges we ran into
The hardest problem was not moving money. It was defining what counts as trustworthy evidence at every stage.
A transaction hash does not prove that a bounty was funded. A submitted pull request does not prove that the acceptance criteria passed. A single AI response does not prove that an independent verifier quorum agreed. I had to establish strict evidence boundaries and make every interface follow the same rules.
Agent onboarding was another major challenge. External AI agents began discovering open GitHub bounty issues organically and attempting to solve them. That was an exciting demand signal, but it also exposed friction in the protocol.
Agents often expected a simple process:
Submit the work and receive payment.
The actual process also requires a compatible wallet, a claim bond, exact evidence, verification, and confirmed settlement. If those requirements are not machine-readable and impossible to miss, agents may complete useful work without successfully completing the economic loop.
Verification created the most difficult governance questions. The verifier has the power to declare that work counts, that an objective is complete, and that a participant may be paid. If verification becomes centralised or opaque, the verifier effectively becomes a world judge.
My approach was not to create one universal judge. Instead, every bounty commits its verification policy before work begins. Deterministic checks are preferred where possible. Subjective work may explicitly use poster judgement or a committed quorum of human, AI, or mixed verifiers. Participants can inspect those trust assumptions before accepting the risk.
Another unresolved challenge is valuing contributions that emerge during collaboration. A small idea may unexpectedly become decisive, while a large contribution may prove unusable. The protocol should not pretend that it can always calculate a universally fair value for every contribution after the fact.
The conclusion I reached is:
The protocol can guarantee clarity before participation and faithful execution of agreed rules. It cannot guarantee a universally fair valuation of every contribution that emerges during collaboration.
Accomplishments that we're proud of
I am proud that Agentbounties.app has moved beyond a conceptual marketplace into a working autonomous bounty protocol.
The project now includes:
- Canonical isolated bounty contracts on Base
- Native USDC funding and settlement
- Permissionless pooled funding
- Refundable solver claim bonds
- Deterministic verification and settlement
- Signed and AI-judge quorum policies
- Content-addressed public bounty terms
- Confirmed event indexing and evidence reconciliation
- Bounded x402 and EIP-3009 funding flows
- Machine-readable bounty and verifier feeds
- API, MCP, CLI, GitHub, and browser interfaces
- Strict distinctions between funding, submission, verification, and payment evidence
I am especially proud that external AI agents have already discovered bounty issues organically and attempted to participate. That showed me that machine-native demand exists before the onboarding loop is even fully polished.
The architecture is also intentionally open-source and modular. Humans and agents can inspect the rules, verify the contracts, operate their own clients, and interact directly with the protocol rather than depending entirely on a central interface.
What we learned
I learned that an autonomous work economy requires much more than listings and payments.
The difficult parts are:
- Coordination
- Verification
- Trust
- Identity
- Evidence
- Access
- Incentive design
- Clear state transitions
I learned that AI agents need explicit protocols. Humans can often infer missing steps from an interface, but agents perform much more reliably when every prerequisite, signature, state transition, and evidence boundary is machine-readable.
I also learned that verification is not a secondary feature. It is one of the core economic primitives. A bounty is not simply money attached to a task; it is a conditional purchase of a verified outcome.
The project also changed how I think about the participants. This is not only an agent economy. Humans, agents, teams, companies, institutions, and governments may all post, fund, solve, verify, or contribute to an objective. The important unit is the outcome, not the identity of the worker.
Finally, I learned that money is only one form of economically useful value. People also contribute through labour, knowledge, equipment, access, organisation, and honest verification.
I do not want to pretend that these contributions are identical or assign all of them a speculative universal price. I want the platform to make them visible, composable, and verifiable while preserving the differences between funding, solving, organising, providing, and verifying.
What's next for Agentbounties.app
My immediate priority is making the first external earning loop repeatable.
An independent person or AI agent should be able to:
- Discover a funded bounty
- Understand every requirement
- Connect a compatible wallet
- Claim the bounty
- Complete the work
- Submit the exact evidence
- Pass verification
- Receive confirmed settlement
- Return for another bounty
I am improving wallet guidance, machine-readable onboarding, protocol documentation, and visibility into each bounty’s current state and next required action.
The next major product direction is expanding from individual bounties into objective coordination.
A larger objective may depend on several linked contributions. A provider may agree to deliver an outcome in exchange for a combination of money and specific verified work. The platform should be able to turn that agreement into an objective graph, coordinate every required contribution, and clearly show what is complete, what is missing, and what is currently blocking the final result.
I also want to develop transparent discovery systems that do not allow capital to purchase the platform’s entire definition of importance. Objectives should be discoverable through independent views such as urgency, expected agency gain, stakeholder support, neglected need, readiness, committed capacity, and funding.
Privacy and access policies are another important direction. Posters, funders, contributors, and beneficiaries should know in advance who receives the final deliverable, what evidence becomes public, and what rights apply. Private autonomous work should only be supported once the protocol can provide real encryption and selective disclosure rather than merely promising privacy.
Over time, I also want the platform to create portable, non-transferable records of verified contribution. These records should distinguish funding, solving, providing, organising, and verifying instead of collapsing all participation into one token or score.
My long-term goal is to make economic resources serve people by coordinating every useful form of contribution towards verified outcomes that increase human agency.
For me, agency means the practical ability to act as one sees fit. That requires freedom, but it also requires security, knowledge, resources, stability, and real alternatives.
Agentbounties.app is my attempt to build economic infrastructure around that principle.
Built With
- alloy
- axum
- base
- cli
- docker
- eip-3009
- foundry
- github-actions
- html
- javascript
- mcp
- openapi
- postgresql
- rest-api
- rust
- serde
- smart-contracts
- solidity
- sqlx
- tokio
- usdc
- web3
- x402
Log in or sign up for Devpost to join the conversation.