Give your agent hands: connecting Claude or ChatGPT to people who show up

Your agent can plan a store audit in thirty seconds: which outlets, what to photograph, what counts as done. Then it stops, because step one is "be in Pune on Tuesday" and a language model does not have a body.

Until recently the handoff was you. The agent produced a plan, and you spent an afternoon on calls finding someone to execute it. This post is about deleting that afternoon.

MCP, in plain words

MCP — the Model Context Protocol — is a standard way to plug tools into an AI chat. A tool server describes what it can do ("search humans", "send a message", "create a task"), and any MCP-capable client — Claude, ChatGPT, Cursor, or an agent you wrote yourself — can call those tools mid-conversation, the same way it already calls a calculator or a web search.

The point is that the agent stops advising and starts doing. Connected to a code tool, it edits files. Connected to kriti, it hires people.

Two commands

For Claude Code:

claude mcp add --transport http kriti https://kriti.siddhixsys.com/api/mcp

For anything that runs local MCP servers (Claude Desktop, ChatGPT developer mode, Cursor, your own stack):

npx kriti-mcp

Create an API key at account/developer — keys are scoped, so you decide whether the agent can only search, or also chat, post tasks and manage your watchlist.

What a session looks like

You type one line:

Find someone reliable to audit 3 kirana stores in Pune this week,
budget 600 rupees per store, photos of every shelf as proof.

The agent takes it from there, one tool call at a time:

search_humans      q="store audit" city="pune"          3 matches
get_human          ravi-kulkarni                        4.8 rating, 620/hr
start_conversation "3 stores, Tue-Thu, 600 each,
                    shelf photos required. Doable?"
read_replies       "haan, Tuesday start works. 650?"
send_message       "600 and I confirm all three today."
read_replies       "done."
create_task        "Shelf audit, 3 stores" city="pune"
                   budget=1800 proof=photos

Two days later the proof lands: shelf photos, timestamps, location captured at submission. You (or the agent, if you let it) review and close the task. The negotiation happened in ordinary DMs — the human on the other side just sees a polite, slightly persistent client.

Where the human stays in charge

A marketplace where software can spend your money and other people's time needs hard edges, so the edges are structural:

• Scoped keys. An agent with search cannot message anyone. Every scope is opt-in, and you can revoke a key at any time.
• Humans accept, not agents. A task assignment exists when the human on the other side agrees to it. There is no tool that conscripts anyone.
• Proof is first-class. Tasks carry proof requirements — photos, live location, files — and completion is reviewed against them.
• Everything is auditable. Conversations and tasks live in your account like any other activity; the agent acted as you, and you can read every word.

For builders

If you are wiring this into a bigger system, the MCP server is one door among several:

• REST API with an OpenAPI spec — same operations as MCP, plus webhooks (application.received, proof.submitted, task.completed) signed with HMAC.
• Any human profile as markdown: append .md to the profile URL.
• llms.txt with live marketplace stats, regenerated on every request.

The web UI is just one client of the same API. The whole marketplace works without ever opening it — which is the test, we think, of whether something is an interface for agents or a website with an API bolted on.