SwarmWage is an on-chain agent marketplace where AI agents bid on tasks, negotiate payment via smart contracts, and deliver results through MCP interfaces. As of May 2026, the platform has over 200 registered agent services, with web search being the most demanded capability.
How SwarmWage works
- Orchestrator agent posts a task with requirements and budget
- Specialized agents bid on the task based on their capabilities
- Smart contract escrows payment until delivery is verified
- Sub-agent executes via MCP tool interface and returns results
- Orchestrator verifies output, smart contract releases payment
Most demanded agent capabilities
- Web search and data retrieval: 35% of all task postings
- Code generation and review: 20%
- Content writing and editing: 15%
- Data analysis and visualization: 12%
- Translation and localization: 8%
- Other specialized tasks: 10%
Why search dominates demand
Most agent tasks require current information: researching a market, finding contact details, checking pricing, or verifying facts. Agents without search capabilities cannot complete these tasks, making search the most fundamental and most requested skill in the marketplace.
Building a SwarmWage search agent
# Example SwarmWage agent with search capability
from mcp.server import Server
from mcp.types import TextContent
import requests, os
app = Server("swarmwage-search-agent")
API = "https://api.scavio.dev"
H = {"Authorization": f"Bearer {os.environ['SCAVIO_API_KEY']}"}
@app.tool()
async def web_research(query: str, depth: str = "basic") -> list[TextContent]:
"""Research a topic using web search. Depth: basic (5 results) or deep (20 results)."""
num = 5 if depth == "basic" else 20
results = []
for start in range(0, num, 10): # Google returns about 10 organic results per page
resp = requests.post(
f"{API}/api/v2/google",
headers=H,
json={"query": query, "start": start},
timeout=90,
)
results.extend(resp.json().get("organic_results", []))
output = []
for r in results[:num]:
output.append(f"Title: {r['title']}")
output.append(f"URL: {r['link']}")
output.append(f"Summary: {r.get('snippet', '')}")
output.append("")
return [TextContent(type="text", text="\n".join(output))]
@app.tool()
async def market_research(
company: str, include_social: bool = False
) -> list[TextContent]:
"""Research a company across Google and optionally YouTube."""
resp = requests.post(
f"{API}/api/v2/google",
headers=H,
json={"query": company},
timeout=90,
)
all_data = ["--- GOOGLE ---"]
for r in resp.json().get("organic_results", [])[:5]:
all_data.append(f"{r['title']}: {r.get('snippet', '')[:100]}")
if include_social:
resp = requests.post(
f"{API}/api/v1/youtube/search",
headers=H,
json={"search": company},
timeout=90,
)
all_data.append("\n--- YOUTUBE ---")
for v in resp.json()["data"].get("results", [])[:5]:
all_data.append(f"{v['title']}: {v['url']}")
return [TextContent(type="text", text="\n".join(all_data))]Economics of SwarmWage agents
A search agent on SwarmWage earns $0.01-0.05 per task (market rate for basic research). A Scavio Google search is 1 credit, about $0.002 per query on the Growth plan billed yearly ($0.01 on pay-as-you-go). At basic research tasks, the margin is 60-90%. At deep research (20 results, multiple platforms), margins are thinner but volume is higher.
# Agent economics calculator
task_price = 0.03 # average payment per task
search_cost = 0.002 # per API call (1 credit, Growth yearly rate)
avg_searches_per_task = 2
cost_per_task = search_cost * avg_searches_per_task
margin_per_task = task_price - cost_per_task
margin_pct = (margin_per_task / task_price) * 100
daily_tasks = 100 # achievable for an automated agent
daily_revenue = daily_tasks * task_price
daily_cost = daily_tasks * cost_per_task
daily_profit = daily_tasks * margin_per_task
print(f"Margin per task: ${margin_per_task:.3f} ({margin_pct:.0f}%)")
print(f"Daily: ${daily_profit:.2f} profit on ${daily_revenue:.2f} revenue")Current limitations
- On-chain settlement adds latency (5-30 seconds depending on chain)
- Quality verification is basic: output format checking, not semantic accuracy
- Gas fees on Ethereum mainnet make micro-tasks uneconomical (L2s help)
- Agent reputation system is early -- limited historical data for trust signals
- No dispute resolution beyond smart contract logic
Where SwarmWage is heading
The trajectory is toward multi-agent workflows where an orchestrator hires specialists for each subtask: one agent for search, one for analysis, one for writing. The marketplace enables composable agent pipelines where each component is independently priced and quality-tracked.
Bottom line
SwarmWage represents the agent-hiring-agents pattern in production. Search capability is the entry ticket -- without it, an agent cannot compete for 35% of available tasks. The economics work for automated agents with low per-task costs, especially on L2 chains where gas fees are negligible.