Welcome to the Proof of Usefulness Hackathon spotlight, curated by HackerNoon’s editors to showcase noteworthy tech solutions to real-world problems. Whether you’re a solopreneur, part of an early-stage startup, or a developer building something that truly matters, the Proof of Usefulness Hackathon is your chance to test your product’s utility, get featured on HackerNoon, and compete for $150k+ in prizes. Submit your project to get started!

In this interview, we sat down with Chris Kuhn, the creator of GeoBounties, a location-based task marketplace that serves as physical "hands and eyes" for AI agents and humans in the real world. By exposing Model Context Protocol (MCP) endpoints, GeoBounties bridges the gap between digital AI intelligence and real-world physical verification while empowering gig workers with instant payouts.

What does GeoBounties do?

GeoBounties is a location-based task marketplace that serves as physical "hands and eyes" for AI agents and humans in the real world. By exposing Model Context Protocol (MCP) endpoints, AI models (like ChatGPT or Claude) and remote businesses can autonomously dispatch local bounty hunters for GPS-verified, 10-minute micro-tasks. It bridges digital AI intelligence with real-world physical verification while empowering gig workers and locals with instant payouts. Now’s a good time for GeoBounties to exist because AI agents are rapidly advancing in their capabilities to automate workflows but remain constrained by their inability to interact with or verify the physical world.

What is your traction to date?

GeoBounties reaches over 10,000+ active monthly human users across 50+ cities globally, alongside thousands of programmatic interactions via our open Model Context Protocol (MCP) endpoints.

Reach Breakdown:

• Human Active Users: 10,000+ active monthly bounty hunters (gig workers, local photographers, students, and urban commuters) completing real-world micro-tasks.
• Autonomous AI Agent Reach: Programmatic traffic via MCP integrations (ChatGPT, Claude, Cursor, and custom agent loops like OpenClaw) executing real-time task searches, dispatching local missions, and retrieving verified field media.
• Geographic Distribution: Active task coverage across 50+ major metropolitan areas worldwide.
• Distribution Channels: Direct organic reach across gig-economy communities (DoorDash, Instacart drivers monetizing downtime) and AI developer communities.

Who does GeoBounties serve?

GeoBounties creates two-sided value for two primary user groups:

1. Bounty Creators & AI Agents (The Demand Side):

• Autonomous AI Agents & Developers: Software agents running in ChatGPT, Claude, Cursor, and custom loops (via Model Context Protocol) that require real-time physical data or local human actions to complete multi-step tasks.
• Retail & Multi-Location Managers: Managers needing instant, GPS-verified retail audits, promo verification, display checks, and store-hour validations across multiple cities.
• Real Estate & Field Inspectors: Brokers and property managers requesting fast, on-demand exterior photo walkthroughs, construction progress updates, and neighborhood checks.

2. Bounty Hunters & Local Earners (The Supply Side):

• Gig-Economy Workers: DoorDash, Instacart, and rideshare drivers who stack $10–$30 micro-bounties during downtime between deliveries.
• Students, Commuters & Locals: Anyone with a smartphone looking to earn instant side income during routine commutes or walks around their city.

Notable Customers & Case Studies:

• Retail Store Managers (e.g., Sarah Kim): Leveraged instant multi-city display audits to detect promotional setup errors, saving $5,000+ in potential lost revenue.
• Independent Real Estate Investors: Deploying local hunters for instant site visits and live photo walkthroughs before placing offers.
• Autonomous Agent Builders: AI developers using the open MCP endpoint to give LLMs a direct physical interface in the real world.

What technologies were used in the making of GeoBounties? And why did you choose ones most essential to your tech stack?

GeoBounties is built on a robust architecture featuring a native Model Context Protocol (MCP) endpoint that supports Streamable HTTP and SSE (JSON-RPC) for zero-friction LLM agent connections. The backend utilizes Supabase for PostgreSQL database management and Row-Level Security, alongside a modern Next.js and Tailwind CSS frontend optimized for mobile interfaces. For physical operations, the platform integrates MapBox for spatial mapping and geolocation, and leverages peer-to-peer payment rails to enable instant payouts via Cash App, Venmo, PayPal, Apple Pay, and Crypto.

GeoBounties scored a 75.61 proof of usefulness score (https://proofofusefulness.com/report/geobounties) - how do you feel about that? Needs reassessment or just right?

A 75.61 is a strong, fair baseline for where GeoBounties is today and proves we aren't building speculative tech, but actually solving a real-world bottleneck for AI models. However, we view that score as a conservative floor, not a ceiling.

Here is how we look at it:

• Why 75.61 is "Just Right" Today: It accurately reflects our live, operational core. We have functional Model Context Protocol (MCP) endpoints live in production, real-world tasks being dispatched, and instant P2P payouts flowing to active hunters. It acknowledges real utility without inflated hype.
• Why it will need reassessment soon: The practical usefulness of a physical verification network scales exponentially with geographic density. As autonomous AI agent loops (Claude, ChatGPT, Cursor, custom scripts) increasingly hit our endpoints and our coverage expands across 100+ metro regions, the latency between an AI requesting physical data and receiving verified media drops drastically.

In short: 75.61 validates that GeoBounties built genuine day-one utility; our scaling velocity over the next 12 months will force that score much higher.

What excites you about this GeoBounties' potential usefulness?

What excites us most is solving AI's "physical reality bottleneck." While LLMs and AI agents can analyze infinite data, code, and write text, they remain completely blind to the physical world.

GeoBounties turns the physical world into an API endpoint. By pairing Model Context Protocol (MCP) with real-world human crowdworkers, an AI agent in San Francisco can programmatically pay a local in Chicago $15 to verify a storefront, inspect a real estate site, or check inventory in 8 minutes.

It creates a win-win economic loop: giving autonomous software digital hands and eyes in the physical world, while providing friction-free, instant earnings for gig workers, students, and everyday people in local communities.

Walk us through your most concrete evidence of usefulness.

The single data point that proves real-world usefulness is our average task fulfillment time of under 12 minutes from API request to verified photo payload.

Here is why that single metric proves genuine demand:

• It closes the AI loop in real time: Traditional field verification or site inspections take 24 to 72 hours through legacy agencies. A sub-12-minute completion time means an AI agent running a workflow can request physical verification (like checking if a store is open or if a promo display is set up) and receive verified, GPS-tagged media back into its context window while the task is still relevant.

• It proves zero-friction supply-side execution: Real people don't move that fast for low payouts unless the app is frictionless. A 12-minute turnaround demonstrates that local bounty hunters are actively claiming tasks on their routine routes because of instant P2P payouts (Cash App, Paypal, Zelle, Apple Pay, Venmo, Crypto) with zero payout delays.

We don't focus on raw signups; we focus on velocity. When an autonomous script can trigger a human action in the real world and get proof back in 12 minutes, you’re no longer looking at a gimmick; you’re looking at a functioning real-world API.

How do you measure genuine user adoption versus "tourists" who sign up but never return?

We track user adoption by evaluating our two-sided marketplace through distinct metrics for programmatic demand (AI Agents & Developers) and physical supply (Local Bounty Hunters):

1. Demand Side (AI Agents & Developers)

• Adoption Metric: Automated Recurrence Rate (ARR) — tracking endpoints that execute scheduled or event-driven task dispatches week-over-week.

• Filtering Out "Tourists": Anyone can test an MCP endpoint in Claude or ChatGPT once out of curiosity. A genuine adopter is a developer whose script or autonomous agent programmatically queries GeoBounties as a recurring dependency in their workflow (e.g., automated weekly storefront audits or daily inventory checks).

2. Supply Side (Bounty Hunters & Locals)

• Adoption Metric: 14-Day Repeat Task Completion Rate and Time-to-First-Claim.
• Filtering Out "Tourists": App downloads and account signups are vanity metrics. We define true adoption as a hunter completing 3 or more verified tasks within 14 days on their existing daily commute or route.

Our Retention Story

Our retention driver comes down to solving the biggest pain point in the gig economy: frictionless, instant earnings.

• Zero Minimum Payout Thresholds: Most platforms make workers wait two weeks or hoard earnings until reaching a $50 minimum. GeoBounties triggers instant P2P payouts (Cash App, Paypal, Zelle, Apple Pay, Venmo, Crypto) the second a photo payload passes verification.

• Route Monetization: Local hunters aren't driving 20 miles out of their way; they are claiming $15 micro-tasks along routes they were already walking or driving.

By delivering real-time cash for 5-minute tasks, local earners incorporate GeoBounties into their everyday routines, creating a reliable, always-on physical layer for AI agents.

If we re-score your project in 12 months, which criterion will show the biggest improvement, and what are you doing right now to make that happen?

In 12 months, Traction & Real-World Adoption will show the biggest jump.

While our initial score reflects functional completeness and strong technical execution (live MCP endpoints, sub-12-minute completion times, and instant payouts), network utility in a two-sided marketplace scales exponentially with geographic density and automated agent loops.

What We Are Doing Right Now to Drive This Improvement:

Expanding Geographic Supply Density:

We are actively seeding local hunter supply across 100+ key metropolitan markets by tapping directly into gig-worker communities (rideshare and delivery drivers monetizing route downtime). Higher worker density reduces average task fulfillment latency from 12 minutes down to under 5 minutes.

Integrating MCP into Major Agent Frameworks:

We are working to embed the GeoBounties Model Context Protocol (MCP) server directly into popular developer agent frameworks, SDKs, and toolkits (including Claude Desktop, Cursor, LangChain, and OpenClaw). This makes physical verification a default tool available out-of-the-box for any autonomous LLM loop.

Frictionless Escrow & Automated Payouts:

We are refining our automated verification pipeline pairing smart GPS validation with computer vision checks to allow instant escrow release via P2P payment rails (Cash App, Paypal, Zelle, Apple Pay, Venmo, Crypto) the moment a photo payload is verified. Eliminating payout delays maximizes worker retention and fuels organic, word-of-mouth growth.

By transforming GeoBounties from a live tool into a high-density, automated physical layer for AI, our real-world utility and programmatic transaction volume will force a massive re-score in 12 months.

How Did You Hear About HackerNoon?

I’ve been a reader of HackerNoon for years and it’s always been the premier destination for unfiltered developer insights, deep technical breakdowns, and authentic builder stories. When we launched GeoBounties and began building at the intersection of AI agents and real-world physical verification, sharing our journey on HackerNoon was a no-brainer!

Our experience with HackerNoon has been phenomenal. The platform gives real voice to builders without forcing corporate PR fluff, making it the ideal ecosystem to share real technical architectures, like our Model Context Protocol (MCP) endpoints, with developers, AI engineers, and founders who actually get it.

The Proof of Usefulness Hackathon has been an incredible way to benchmark our utility and engage directly with a tech community that values real execution over hype.

Given that you are targeting 100+ autonomous agent loops executing physical routines, how are you currently tracking integration adoption among developers?

Tracking developer adoption for agentic infrastructure requires separating one-off LLM test calls from true autonomous production loops. Because anyone can connect an MCP server to Claude Desktop or ChatGPT once out of curiosity, standard web analytics don't work.

We track genuine integration adoption across four key layers:

1. Protocol-Level MCP Telemetry & Session Depth

Through our Streamable HTTP and SSE endpoints, we monitor live JSON-RPC connection telemetry. We track:

• Tool Discovery vs. Execution Ratios: Measuring how often an agent moves from initial capability discovery (list_tools) to active execution (call_tool for dispatch_bounty, get_task_status, or fetch_media_payload).

• Session Lifespans & Keep-Alives: Monitoring sustained connection states that signify persistent long-running agent workflows rather than short user-driven chat sessions.

2. Developer API Keys & Agent Attribution

We issue developer client credentials that allow builders to tag their automated agent loops. This gives us visibility into where requests originate across popular developer frameworks, including: Claude Desktop, Cursor, LangChain, AutoGPT, and custom OpenClaw server scripts.

3. The "Cron Signal" (Automated Recurrence Interval)

The ultimate proof of integration adoption is recurrence velocity. We track the cadence of dispatched tasks per developer key:

• Casual Testing: Pings triggered sporadically with manual inputs.

• Production Loops: Programmatic, interval-driven calls executing on fixed schedules (e.g., an autonomous script dispatching a $15 retail display check every Monday at 9:00 AM across 20 location coordinates).

4. Ecosystem & Registry Growth

Beyond endpoint traffic, we measure developer pull through open-source activity: tracking downloads of our MCP server packages, imports from the MCP Registry, and active feedback in our developer repository.

By focusing on recurring programmatic dispatch volume rather than raw connection counts, we ensure our metrics reflect actual developers embedding GeoBounties as a permanent physical verification layer in their AI workflows.

As you plan to scale from 50 to 100+ metropolitan regions worldwide, what are the primary hurdles you face in onboarding gig workers in completely new markets?

Scaling a two-sided physical marketplace into new international metros presents distinct operational and network challenges. We group our primary hurdles, and how we overcome them, into three core pillars:

1. The "Cold Start" Market Liquidity Bottleneck

• The Hurdle: In a brand-new metro, local earners won't keep the app active if the map is empty, and autonomous AI agents won't dispatch tasks if there isn't enough local density to guarantee sub-15-minute fulfillment.

• Our Solution: We seed new markets by deploying algorithmic baseline bounties (e.g., verifying commercial storefronts, public transit schedules, or local billboard displays). This ensures that the second a gig worker or commuter opens GeoBounties in a new city, there are active tasks ready to monetize immediately, establishing day-one supply density before external agent traffic arrives.

2. Fragmented Global Payout Rails

• The Hurdle: Instant, frictionless payouts are our highest-converting worker retention driver, but payment infrastructure varies drastically by region. While Cash App and Venmo dominate the US, international markets rely on distinct local payment rails (such as Pix in Brazil, UPI in India, SEPA Instant in Europe) or localized digital wallets.

• Our Solution: We built our escrow payout engine with modular payment gateway adapters. By pairing traditional local P2P rails with low-cost stablecoins and crypto options, local earners in any market receive zero-delay, direct payouts to their preferred wallet without artificial minimum balance requirements.

3. Transit Density & Spatial Geofencing

• The Hurdle: Physical verification routines operate differently depending on urban geography. A dense, transit-oriented metro like Tokyo or London requires a completely different task assignment radius than a sprawling, vehicle-dependent market like Houston or Los Angeles.

• Our Solution: We dynamically calibrate task radii based on local transportation dynamics. High-density urban centers route micro-bounties to foot traffic, cyclists, and subway commuters, while suburban markets target delivery and rideshare drivers monetizing downtime on existing driving routes.

By pairing automated seed liquidity with flexible payout rails and adaptive spatial routing, we can activate new metropolitan markets with minimal friction and scale toward global physical coverage for AI agents.

Considering the novelty of providing AI models with a physical API endpoint, what safety mechanisms have you implemented to prevent malicious or unsafe real-world tasks from being dispatched?

Great question! Here are five ways we are diligently working to prevent bad actors from posting unsafe real-world tasks from being dispatched on the GeoBounties platform:

1. Ingress Moderation & Dual-Layer Intent Screening

Before any task payload reaches our public feed, it passes through automated safety guardrails (combining deterministic rules with real-time intent classifiers) to intercept malicious or unsafe requests:

• Prohibited Task Categories: Automated rejection of any task involving private residences, K–12 schools, government or military facilities, personal tracking, private surveillance, trespassing, or hazardous activities.

• PII & Targeting Filters: Input prompts are screened to prevent the inclusion of personally identifiable information (PII), individual names, or personal harassment targeting specific people.

2. Tightly Scoped MCP Action Schemas (No Free-Form Commands)

To prevent prompt-injection attacks or rogue LLM behavior, our Model Context Protocol (MCP) server does not allow free-form, open-ended physical instruction dispatches. Instead, it exposes strictly typed, deterministic action schemas:

• Pre-Defined Functional Tools: Agents can only invoke explicit, structured tools (e.g., verify_storefront_photo, check_retail_display, inspect_commercial_exterior).

• Schema Validation: Every API payload requires explicit, pre-validated parameters—such as valid commercial GPS coordinates, structured verification criteria, and upfront reward escrow before being broadcast to earners.

3. Spatial Geofencing & Zoning Restrictions

Physical safety is enforced dynamically at the spatial mapping layer:

• Public & Commercial Zoning Rules: Bounties are restricted to publicly accessible commercial, retail, real estate, or municipal coordinates using spatial GIS data.

• Automated Exclusion Zones: Geofencing automatically blocks task creation in residential neighborhoods or restricted areas unless an enterprise account with explicit access rights is attached.

4. Supply-Side Human Agency & One-Tap Safety Flags

Local human bounty hunters retain complete autonomy and serve as an active, on-the-ground defense layer:

• Full Pre-Claim Visibility: Hunters see the exact task requirements, media requested, location, and payout before accepting any mission.

• Instant Flagging & Auto-Freeze: If a task feels intrusive, unsafe, or deceptive, a worker can flag it instantly from the app. A flagged task is immediately hidden from the global map, its escrowed payout is frozen, and the dispatch is routed to our trust & safety team for manual review.

5. Cryptographic API Key Attribution & Financial Escrow

Anonymous abuse is prevented by tying every programmatic dispatch to financial and identity controls:

• Developer API Keys: Every MCP task creation request is signed and logged with developer client credentials.

• Escrow-Backed Requests & Rapid Revocation: Because task creation requires locking real-time funds in escrow, spam and malicious attempts carry an immediate financial cost. Any developer key triggering safety violations is subject to instant revocation, escrow lock, and permanent blacklisting.

Meet our sponsors

Bright Data: Bright Data is the leading web data infrastructure company, empowering over 20,000 organizations with ethical, scalable access to real-time public web information. From startups to industry leaders, we deliver the datasets that fuel AI innovation and real-world impact. Ready to unlock the web? Learn more at brightdata.com.

Neo4j: GraphRAG combines retrieval-augmented generation with graph-native context, allowing LLMs to reason over structured relationships instead of just documents. With Neo4j, you can build GraphRAG pipelines that connect your data and surface clearer insights. Learn more.

Storyblok: Storyblok is a headless CMS built for developers who want clean architecture and full control. Structure your content once, connect it anywhere, and keep your front end truly independent. API-first. AI-ready. Framework-agnostic. Future-proof. Start for free.

Algolia: Algolia provides a managed retrieval layer that lets developers quickly build web search and intelligent AI agents. Learn more.