Gigr

Verified people. Safe payments. And an AI that makes hiring as easy as texting.

Comment

Inspiration

Two experiences I had in my country made me build this project. The first: my leaking bathroom sink and a phone full of unanswered "does anyone know a plumber?" messages. Nobody I knew around me could name a plumber they trusted, and the strangers I found online did not seem trustworthy enough to complete the job without me fearing, as I had been scammed by a plumber before.

The second is on the other side of the proverbial freelancing coin. I was also an animator who delivered a finished project, only to never get paid on the fully agreed on price after all my hard work. It turns out trust is broken on both sides of the market: clients fear being scammed by someone they hired, and workers fear doing the job and never seeing the money.

I built Gigr for both of those people: the client who wants to know they can trust who they hire, and the worker who wants to know they'll actually get paid for work they've done.

What it does

Gigr is a neighborhood marketplace where trust is the core product:

  • Verified people: Every provider carries real reputation history, plus on-chain "vouches" from neighbors who actually hired them.
  • Safe payments: When you hire someone, the money goes into an escrow program that nobody can touch. It's released to the worker only when you confirm the work is done: so workers get paid, and clients only pay for work they're happy with.
  • Easy to use: You don't browse and click through endless forms. Your AI assistant finds a trusted provider, posts the job, holds the payment, and releases it when you're satisfied: all in plain language.

Gigr works for both sides of the market: hire someone trustworthy, or be hired: your agent can list the service you offer, field requests, and protect your payment the exact same way.

How I built it

I built a modern full-stack app with these:

  • Frontend: React + TypeScript + Vite, deployed on Vercel.
  • Backend: FastAPI + Postgres/PostGIS (deployed on Koyeb), which powers proximity search: "find providers near me" is ranked by real distance.
  • Real escrow: Payments are locked in a Solana smart contract. Funding, releasing, and completion are genuine on-chain transactions, not mockups.
  • Real reputation: Completed jobs mint vouches as on-chain tokens, making history tamper-proof and fully portable with the provider.
  • Agent-native (WebMCP): I exposed Gigr as a set of 14 WebMCP tools (get_user_location, search_providers, post_job, post_service, fund_escrow, release_escrow, accept_job, and more) inside the user's logged-in browser, so an AI agent can act on the user's behalf with no separate agent login. Sensitive tools are only visible when you're signed in.

Challenges I ran into

The hardest lesson was understanding how an agent should act for a real user. At first, I assumed the agent had access to the logged-in session; I learned that WebMCP tools only work when they run inside an authenticated tab. Any request made from outside that context can't carry your login: that took a few frustrating debugging sessions to nail.

From there came a subtler design problem: WebMCP has no built-in way to unregister a tool, so I had to tie every sensitive tool to an AbortSignal and tear it down the moment the user signs out: ensuring a signed-out session cannot make escrow calls. I also built the escrow state machine to refuse invalid state transitions (e.g., "you can't release a payment that was never funded") with clear explanations, so the agent guides the user instead of erroring out.

Finally, building for both sides of the market effectively doubled my workload: I had to serve both "I want to hire" and "I want to be hired" flows, each with its own tailored agent interaction model.

Accomplishments that I'm proud of

  • A client can move seamlessly from "find me a verified plumber near me" to real USDC sitting safely in an on-chain escrow: all directly from a chat interaction.
  • A provider can ask their agent to get them hired: listing services, fielding requests, and accepting jobs autonomously.
  • Reputation is genuinely on-chain and ungameable, not a superficial star rating that can be inflated or bought.
  • The agent's "sense of the user": location, currency, and preferences: comes dynamically from the app context itself rather than repeatedly asking the user.
  • The agent can also call the user when a task is done but this uses Twilio's free tier for now so it only works for me (the tester).

What I learned

  • Authentication and identity are the real product surface: The most impressive-sounding agent features collapse the moment the agent can't act safely as the user with explicit human consent. Signing in stays a crucial human moment.
  • Escrow is a product feature, not just a crypto feature: I used a blockchain because it provides what traditional databases cannot: a trustless payment execution that nobody can quietly reverse. However, end users never need to care about the underlying tech.
  • Build for both sides: A marketplace only thrives when both the hirer and the worker feel completely protected: most platforms historically only cater to one.

What's next for Gigr

  • Move escrow contracts to Solana mainnet and integrate real ₦ (Naira) and other currency payments on/off-ramps so local currency seamlessly swaps to USDC inside the app.
  • Expand the agent's capabilities to handle multi-step negotiation and automated dispute resolution (with human-in-the-loop oversight).
  • Grow the vouch graph so reputation seamlessly follows providers across cities and platforms.
  • Launch a dedicated mobile experience and expand into more service categories: from plumbers to digital animators who, this time, always get paid.
Share this project:

Updates

Submission history