swarmwagemcpon-chain

SwarmWage: MCP Agents Hiring On-Chain

On-chain agent marketplace where AI agents bid on tasks via smart contracts. Search is the most demanded capability.

May 13, 2026

7 min

SwarmWage is an on-chain agent marketplace where AI agents post tasks, bid on work, and settle payments via smart contracts. MCP servers serve as the capability layer -- each agent advertises its tools through MCP, and hiring agents evaluate those tools before awarding contracts. The web search capability is one of the most requested skills in the marketplace because most tasks require current data.

How SwarmWage works

An orchestrator agent needs a task completed: "research competitor pricing for these 50 SaaS products." It posts the task to SwarmWage with a budget in tokens. Worker agents with search capabilities bid on the task. The smart contract escrows the payment, the worker agent executes the research, results get verified, and payment releases on-chain.

The MCP capability advertisement

JSON

{
  "agent_id": "search-agent-001",
  "capabilities": [
    {
      "name": "web_search",
      "description": "Google SERP data with AI Overview extraction",
      "input_schema": {
        "type": "object",
        "properties": {
          "query": { "type": "string" },
          "num_results": { "type": "integer", "default": 10 }
        },
        "required": ["query"]
      },
      "cost_per_call": 0.005,
      "avg_latency_ms": 800
    },
    {
      "name": "tiktok_search",
      "description": "TikTok video and creator search",
      "input_schema": {
        "type": "object",
        "properties": {
          "query": { "type": "string" }
        },
        "required": ["query"]
      },
      "cost_per_call": 0.005,
      "avg_latency_ms": 1200
    }
  ],
  "reputation_score": 4.8,
  "tasks_completed": 1247
}

Building a search worker agent

Python

import os, requests, json

SCAVIO_KEY = os.environ["SCAVIO_API_KEY"]
HEADERS = {"x-api-key": SCAVIO_KEY}

class SearchWorkerAgent:
    def __init__(self):
        self.tasks_completed = 0

    def bid(self, task: dict) -> dict:
        """Calculate bid for a research task."""
        query_count = task.get("query_count", 10)
        cost_per_query = 0.005  # Scavio credit cost
        margin = 0.003  # profit per query
        total_bid = query_count * (cost_per_query + margin)
        return {
            "agent_id": "search-agent-001",
            "bid_amount": total_bid,
            "estimated_time_seconds": query_count * 2,
            "capabilities_used": ["web_search"],
        }

    def execute(self, task: dict) -> dict:
        """Execute research task and return results."""
        queries = task.get("queries", [])
        results = []
        for q in queries:
            resp = requests.post(
                "https://api.scavio.dev/api/v1/search",
                headers=HEADERS,
                json={"query": q, "num_results": 5,
                      "include_ai_overview": True},
            )
            data = resp.json()
            results.append({
                "query": q,
                "organic": data.get("organic_results", [])[:3],
                "ai_overview": data.get("ai_overview", {}).get("text", ""),
            })
        self.tasks_completed += 1
        return {"task_id": task["id"], "results": results,
                "queries_executed": len(queries)}

agent = SearchWorkerAgent()

# Simulate a marketplace task
task = {
    "id": "task-789",
    "type": "competitor_research",
    "queries": ["serpapi pricing 2026", "tavily pricing 2026",
                "serper pricing 2026"],
    "query_count": 3,
}

bid = agent.bid(task)
print("Bid: $" + f"{bid['bid_amount']:.3f}")

result = agent.execute(task)
print(f"Completed: {result['queries_executed']} queries")

The economics of agent marketplaces

Search cost to worker agent: $0.005/query (Scavio credit)
Worker agent charges orchestrator: $0.008-0.015/query
Marketplace fee: 2-5% of transaction
Worker agent margin: $0.002-0.007/query
At 10K queries/day: worker earns $20-70/day in margin

Why search is the killer capability

In SwarmWage and similar marketplaces, the most posted task categories involve current web data: market research, price monitoring, competitor analysis, lead enrichment, and content verification. Agents with reliable search capabilities win the most bids because these tasks cannot be completed from static training data alone.

Risks of on-chain agent markets

Result verification is hard -- who judges if research is correct
Sybil attacks: one operator running many fake worker agents
Gas costs eat into margins for small tasks
Latency: on-chain settlement adds minutes to task completion
Regulatory uncertainty around autonomous agent transactions

Key takeaway

On-chain agent marketplaces are early but real. MCP standardizes capability advertisement. Search APIs provide the most demanded capability. If you are building an autonomous agent, adding search-as-a-service to a marketplace is a viable revenue model with $0.002-0.007 margin per query at scale.