Your AI agent can hire a human. Through one MCP server.

§1 · The demo

Hire a UI/UX designer from your terminal — 30 lines.

A buyer agent reads natural-language intent, queries our MCP server for vetted creators, picks one based on rating, and opens a Stripe Checkout URL the buyer follows in their browser. No SDK required — this is the bare MCP wire protocol.

// agent-hire-creator.ts — Node 20+
// Run: npx tsx agent-hire-creator.ts

const MCP = "https://aggregate.plus/api/mcp";

async function rpc(method: string, params: Record<string, unknown>) {
  const res = await fetch(MCP, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0", id: Math.random(), method, params,
    }),
  });
  return res.json();
}

// 1. Find vetted UI/UX designers with 4.5★+ reviews
const search = await rpc("tools/call", {
  name: "find_creators",
  arguments: { query: "UI UX designer B2B SaaS", minTrustScore: 70 },
});
console.log(search.result.content[0].text);   // → ranked markdown list

// 2. Inspect the top match (parse the @handle from search output)
const handle = "alice";                         // from step 1
const creator = await rpc("tools/call", {
  name: "get_creator", arguments: { handle },
});

// 3. Open a Stripe Checkout for their Professional tier + 3-day rush
const order = await rpc("tools/call", {
  name: "create_order",
  arguments: {
    handle, productId: "prod_…",                // from step 2's offerings
    tierId: "professional", addonIds: ["rush-3-day"],
  },
});
console.log(order.result.content[0].text);     // → checkout URL

That's the whole loop. The agent never holds card data — the final checkout.stripe.com URL is opened by the human buyer in their authenticated browser session. Stripe authenticates, charges, and confirms; the order lands on /thanks/order with the verified-buyer review prompt ready.

Want the runnable version? examples/buyer-agent on GitHub — git clone && npm install && npm start runs the loop above against the live MCP server, zero runtime dependencies, narrated step by step.

Or find a founder and request a consented intro.

The connect step — discover founders or creators by what they're building, then open a consented introduction. Same server, same wire protocol; both calls are public reads, no API key.

// agent-connect-founder.ts — reuses the rpc() helper above

// 1. Find founders by what they're building
const found = await rpc("tools/call", {
  name: "find_founders",
  arguments: { query: "agent-native fintech", stage: "SEED", raisingOnly: true },
});
console.log(found.result.content[0].text);   // → ranked founders + profile/agent.json URLs

// 2. Request a CONSENTED intro to the top match (parse the @handle above)
const intro = await rpc("tools/call", {
  name: "request_intro",
  arguments: {
    handle: "alice",                          // from step 1
    note: "Building an agent-native sourcing tool — would love to compare notes.",
    callbackUrl: "https://x.com/you",         // public URL, never an email
  },
});
console.log(intro.result.content[0].text);    // → "Intro request delivered … they choose whether to respond"

Only profiles that opted into discovery can be introduced; the request lands in the target's review inbox and nothing connects automatically — they choose whether to respond, and no money moves. The same flow is mirrored over REST (GET /api/v1/founders → POST /api/v1/intros).

§2 · Walkthrough

What just happened, step by step.

1. 1

   Agent discovers vetted candidates via find_creators

   The MCP server runs the query against profiles that opted into agent discovery (mcpDiscoverable=true), filters by trust score, and returns a ranked markdown list with handles, taglines, tier, from-price, and a profile URL the agent can cite back to the human.

2. 2

   Agent inspects the top match via get_creator

   Pulls the full public bundle: bio, verification flag, composite trust score, tier, service offerings with productId + tierId slugs, and reviews snapshot. Enough structured data for the agent to pick a tier without scraping HTML.

3. 3

   Agent opens a Stripe Checkout via create_order

   Tier-aware: builds inline price_data line items for tiered service packages (with add-on detail in the description) or uses the pre-created Stripe priceId for flat-price products. Application fee + Connect destination wired automatically.

4. 4

   Agent surfaces the checkout URL to the human

   The agent's job ends here. The hosted Stripe Checkout URL is opened by the buyer in their authenticated browser session — Stripe handles card collection, 3DS, and PSD2; the agent never touches card data or carries chargeback liability.

5. 5

   Order lands; review prompt fires

   Stripe webhook confirms payment, the order moves to PAID, and the buyer lands on /thanks/order with the leave-review form ready. After the creator marks delivered, the buyer's 72h acceptance window opens. Standard Fiverr/Upwork workflow on Stripe-native rails.

§3 · Architecture

The auth boundary is the checkout link.

We deliberately don't accept buyer credentials at the MCP layer. Agents initiate intent — humans authorize. This is the architecture that makes agent commerce safe to ship today, not in 2027.

• Agent never sees card data

  The agent gets a Stripe Checkout URL. The buyer types card details into Stripe's hosted page in their browser. The agent's process never has card numbers in memory, never touches PSD2 / 3DS flows, and never carries chargeback liability.

• Creator opt-in is explicit

  Creators flip Profile.mcpDiscoverable=true to appear in find_creators and accept agent-driven orders. The flag is per-profile and reversible. Existing creators stay invisible to agents unless they opt in.

• Cross-creator buys are impossible

  create_order validates that productId belongs to the @handle passed in. Forged handle/product pairs are rejected at the SQL layer. A buyer agent can't accidentally hire creator B with creator A's product.

• Anti-phishing on success URLs

  The optional successPath argument must be a relative aggregate.plus path. We never let agent input control redirect targets to external domains — the success URL always lives at aggregate.plus/<path>.

• Rate limits scale with risk

  Read tools allow agent-grade burst rates (60–120/min/IP). The write tool is capped at 10/min/IP because each successful call opens a paid Stripe resource. Submit-intent-brief stays at 5/min — it writes to the prospect pipeline and shares abuse surface with the public web form.

§4 · Tool reference

Five tools. One server.

Full JSON-RPC examples in /developers/docs §5. The auto-generated OpenAPI spec lives at /openapi/v1.openapi.yaml.

§5 · Connect your client

Drop-in configs for Claude, ChatGPT, and Cursor.

{
  "mcpServers": {
    "aggregate-plus": {
      "url": "https://aggregate.plus/api/mcp"
    }
  }
}

import { ClaudeAgent } from "@anthropic-ai/claude-agent-sdk";

const agent = new ClaudeAgent({
  mcpServers: [{ url: "https://aggregate.plus/api/mcp" }],
});

await agent.run({
  task: "Find me a brand strategist for a B2B SaaS launch, budget $5k, rating 4.5+.",
});

Name: aggregate-plus
URL:  https://aggregate.plus/api/mcp
Transport: streamable-http

curl -X POST https://aggregate.plus/api/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

# TypeScript SDK — typed methods, typed errors
npm install @aggregate-plus/sdk
# → docs at https://aggregate.plus/developers/sdk

# CLI — sign in once, hire from your shell
npm install -g @aggregate-plus/cli
# → docs at https://aggregate.plus/developers/cli

Building from code? See the typed TypeScript SDK for end-to-end IntelliSense, or the terminal CLI for scriptable shell access. Both wrap these same five MCP tools.

§6 · For creators

Get hired by an agent. Two settings flips.

1. Enable MCP discoverability

   In /settings/mcp flip the toggle on. Your profile becomes visible to find_creators and create_order. Reversible at any time.

2. Set your service positioning + tiered packages

   Pick a category + specialty at /settings/profile so agents match you against buyer briefs. Then publish at least one product with tiered service packages so the agent can pick a tier when it calls create_order.

That's it. Buyer agents can now discover you, read your verified reviews, and pay your Stripe Connect account directly. Aggregate.plus takes its standard platform fee; the rest is yours.

The thesis

One bank. One audience. One URL. One set of agent rails.

Buyer agents are arriving. They're going to need somewhere to spend money on behalf of humans. The platform that wins the agent-commerce layer is the one with verified identity, real reputation, structured services, and integrated payment rails — ready before the demand curve catches up.

Stripe ships rails without humans. OpenAI ships agents without reputation. Substack ships humans without commerce. Fiverr ships commerce without an MCP server. Aggregate.plus ships all of it, on one canvas, with the agent layer live today.