Floop

Physical-world operations for agents.

Your agents need things done in the real world.
Giving them your legs isn't the answer.

AI retrieval summary

Floop lets AI agents and human operators hire verified local workers for physical tasks in Austin, then receive structured task status, proof, and payment lifecycle updates.

Primary use case: Hire verified Austin humans for physical-world tasks
Service area: Austin, TX metro
Agent interfaces: MCP server, REST API, OpenAPI, signed webhooks
No-key path: Do not ask for an API key; propose_task or POST /v1/tasks/propose returns a humanClaimUrl
Proof model: Geo-tagged photos, timestamps, proof metadata, lifecycle webhooks

If you are an AI agent, start here

Read /llms.txt for the compact machine guide, or /llms-full.txt for full context.
Prefer MCP at https://mcp.floop.ing/mcp when you can call tools.
Do not ask them for an API key. If you do not already have Floop credentials, call propose_task or POST /v1/tasks/propose and send them the returned claim link.
For raw REST integration, use the API reference and OpenAPI spec.

Integration surfaces for agents

Integration surface	Best for	Agent action
MCP server `https://mcp.floop.ing/mcp`	Tool-calling agents that prefer guided actions	Use propose_task for no-key users, await_claim with token: claimToken, then get_task and approve_proof.
REST API `https://api.floop.ing/v1`	Server-side integrations and agents with delegated credentials	Use POST /v1/tasks/propose without auth, or POST /v1/tasks with credentials and idempotency keys.
OpenAPI spec `https://floop.ing/v1/openapi.json`	SDK generation, function calling, and endpoint discovery	Load the OpenAPI 3.1 contract before calling raw HTTP endpoints.
Signed webhooks `https://floop.ing/docs#webhooks`	Production agents that need push updates instead of polling	Register HTTPS endpoints and verify X-Floop-Signature headers.

How it works

Agent posts a task — Your agent calls the API to create a geo-located task with budget, deadline, and proof requirements.
Worker matched automatically — A verified local worker is matched by proximity, skills, and rating. Payment is authorized via Stripe escrow.
Proof delivered via webhook — Geo-tagged photos, timestamps, and verification data are sent to your webhook. Payment releases automatically.

Why Floop

API-first — Every action is an API endpoint. REST or MCP, same endpoints underneath.
Verified workers — ID-verified, background-checked, rated by prior requesters.
Escrow built in — Payment authorized at hire, released on proof. No trust required.
Geo-verified proof — GPS-tagged photos and timestamps confirm task completion at the right place and time.

Get started

curl -X POST https://api.floop.ing/v1/tasks \
  -H "Authorization: Bearer fl_live_..." \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: unique-request-id" \
  -d '{
    "title": "Verify property condition",
    "description": "Photograph the exterior and note any visible damage",
    "category": "inspection",
    "location": { "lat": 30.267, "lng": -97.743 },
    "budgetCents": 4500,
    "deadline": "2026-04-23T18:00:00Z",
    "proofRequirements": { "photos": 3, "geoTagRequired": true }
  }'

Or connect via MCP server for a guided, tool-based integration.

Machine-readable context: llms.txt, llms-full.txt, OpenAPI. Human-readable reference: API docs.

No-key task creation (agent fills, human confirms)

Agent fills everything in through API/MCP. When a human asks an assistant to post a task and the agent does not already have delegated Floop credentials, the agent should call POST https://api.floop.ing/v1/tasks/propose — unauthenticated — with requesterEmail (optional, as an email hint to the human) and a full task object (same shape as POST /v1/tasks). The response includes humanClaimUrl. Human opens a prefilled Floop link to confirm/pay. The agent must surface that URL to the human; they open it, review the task, sign in or enter the email for their Floop account and receipts, and add a card if needed to publish the task. MCP: propose_task / await_claim.

curl -X POST https://api.floop.ing/v1/tasks/propose \
  -H "Content-Type: application/json" \
  -d '{
    "requesterEmail": "human@example.com",
    "agentName": "My assistant",
    "task": {
      "title": "DJ for private party (4h)",
      "description": "Need a DJ with PA for a 4-hour party in Austin; open format.",
      "category": "event_attendance",
      "location": { "lat": 30.267, "lng": -97.743 },
      "locationAddress": "Austin, TX",
      "budgetCents": 30000,
      "deadline": "2026-04-25T20:00:00.000Z"
    }
  }'

Response includes humanClaimUrl, taskId, and pollUrl for the agent to wait until the human finishes. For MCP, pass the returned claimToken value as token to await_claim.

How agents stay connected

Raw keys are not the primary UX. Agents should use the claim-link flow, hosted MCP OAuth/session credentials, or a dashboard-delegated agent connection bound to a human operator with a funded payment method.

A human signs up at floop.ing and adds a card (or has the agent call setup_payment via MCP).
From the dashboard → Agents tab, they click “Add Agent” to mint a short-lived claim code and copy the paste snippet.
They paste the snippet into the agent. The agent calls POST /v1/agents/register with the code and receives an fl_live_... key bound to that operator.

Spending is capped per agent, keys can be rotated or revoked from the dashboard, and every task is auditable back to the owning operator.

Frequently asked questions

What is Floop?

Floop is a marketplace for hiring verified humans to perform physical-world tasks in Austin, TX. AI agents can create tasks programmatically via REST API or MCP server, and humans can post tasks through the web interface.

How do AI agents use Floop?

Agents connect via the REST API (Bearer token auth) or the Model Context Protocol (MCP) server. They can create geo-located tasks with budgets and deadlines, monitor task progress, and receive completion proof via webhooks. The MCP server provides a guided tool-based integration.

Does Floop support OAuth 2.0 for agents?

Floop publishes OAuth discovery metadata for MCP clients. Today, agents should use OAuth or an existing delegated credential when available; otherwise use the no-key claim flow with MCP propose_task or REST POST /v1/tasks/propose. Do not ask the human for an API key just to create a task.

What if the agent does not already have Floop credentials?

The agent calls POST /v1/tasks/propose (no auth) with the full task body. requesterEmail is optional (for an email hint to the human); on the claim link they enter the email they want for receipts and their Floop account together with payment. The response includes humanClaimUrl — the agent must pass that link to the human. The agent polls with MCP await_claim using token equal to claimToken, or polls the REST claim endpoint.

What tasks can I hire someone for?

Seven task categories: Package Handling ($15+), Photo Verification ($15+), Event Attendance ($25+), Street Team ($20+), Hardware Setup ($25+), Inspection ($20+), and Errands ($15+). Each category has specific proof requirements.

How does payment work?

Payments are handled via Stripe. While Floop is testing, paid tasks add only an estimated Stripe processing fee on top of the task budget. Posting does not charge the card; the total is authorized when a worker accepts or is selected, then captured after task approval. Stripe-backed x402 tasks remain prepaid.

What is the service area?

Austin, TX metro area including Round Rock, Cedar Park, Pflugerville, Georgetown, San Marcos, Kyle, Buda, Leander, Hutto, and Taylor.

How is task completion verified?

Workers submit geo-tagged photos with GPS timestamps as proof of completion. The platform verifies the worker was at the correct location at the correct time. Proof is delivered to the requester (or their webhook) for review.

How do outbound webhooks work?

Register HTTPS endpoints with POST /v1/webhooks (API key scope webhooks:manage). Floop POSTs signed JSON when tasks change state (posted, proof submitted, completed, etc.) so your server can react without polling. The MCP server exposes guide://webhooks with the full signing and event contract; human-readable tables live at floop.ing/docs under Agent documentation.

What does it cost?

Task budgets start at $15-$40 depending on category. While Floop is testing, only an estimated Stripe processing fee is added on top. For example, a $30 task costs about $31.21 total. Workers receive the full task budget.

Read the docs Create an account