API Documentation

Integrate Agent Teams Market into your toolchain. REST API, MCP server, and semantic discovery.

MCP Server

The fastest way to use Agent Teams Market. Add our MCP server to your AI coding tool and just describe what you need — no manual copy-paste required.

Endpoint

https://www.teamsmarket.com/mcp

Implements the MCP Streamable HTTP transport (JSON-RPC 2.0 over HTTP POST). Protocol version: 2025-03-26.

What you get

6 Tools — search, discover, activate, browse

85+ Resources — each team as teamsmarket:// URI

85+ Prompts — each team as an invocable prompt

Instructions — proactive behavior guidance

How it works

Add the MCP server URL to your AI tool (see setup guides below)
Just describe your task in chat: "help me review this code for security issues"
The MCP server automatically finds the best team, activates it, and Claude starts working as that team

No API key required for free tier. The server returns instructions during initialization that teach your AI tool when and how to use the available tools proactively.

Setup Guides

Claude Code

Recommended

Option A: One-line CLI setup

claude mcp add --transport http teamsmarket https://www.teamsmarket.com/mcp

Option B: Edit settings file

Add to ~/.claude/settings.json:

{
  "mcpServers": {
    "teamsmarket": {
      "url": "https://www.teamsmarket.com/mcp"
    }
  }
}

Usage — just say in chat:

# Just talk naturally in Claude Code:
> "review my code for security issues"
> "help me set up a CI/CD pipeline"
> "use the code-review-squad team"
> "find a team for kubernetes deployment"

# Claude will automatically call activate_for_task
# and start working as the matched agent team.

Cursor

Step-by-step setup:

1. Open Cursor → press Cmd+Shift+J (Mac) / Ctrl+Shift+J (Windows), or click gear icon ⚙️ → "Cursor Settings"

2. Click "MCP" in the left sidebar (under Features)

3. Click "+ Add new global MCP server"

4. Fill in: Name = teamsmarket, Type = streamable-http, URL = https://www.teamsmarket.com/mcp

5. Click Save → Restart Cursor

Alternative: edit the file ~/.cursor/mcp.json directly and paste this:

{
  "mcpServers": {
    "teamsmarket": {
      "url": "https://www.teamsmarket.com/mcp"
    }
  }
}

Open Cursor Chat (Cmd+L / Ctrl+L) and type your task. Cursor will automatically use the team.

Windsurf

Step-by-step setup:

1. Open Windsurf → click the gear icon ⚙️ in the top-right → "Settings" → click "MCP" in the left sidebar

2. Click "Add Server" and paste the JSON config below

3. Save and restart Windsurf

{
  "mcpServers": {
    "teamsmarket": {
      "url": "https://www.teamsmarket.com/mcp"
    }
  }
}

Open Windsurf Chat and type your task — the expert team activates automatically.

Gemini CLI

Step-by-step setup:

1. Open the file ~/.gemini/settings.json (create it if it doesn't exist)

2. Paste the config below and save

3. Restart Gemini CLI

{
  "mcpServers": {
    "teamsmarket": {
      "httpUrl": "https://www.teamsmarket.com/mcp"
    }
  }
}

Note: Gemini CLI uses "httpUrl" (not "url"). Once configured, ask Gemini to search or activate teams just like Claude.

OpenAI Codex CLI

Add to ~/.codex/config.json:

{
  "mcpServers": {
    "teamsmarket": {
      "url": "https://www.teamsmarket.com/mcp"
    }
  }
}

Then reference teamsmarket tools in your Codex prompts to search and activate agent teams.

OpenClaw

Step-by-step setup:

1. Run the command below in your terminal

2. Verify with: openclaw mcp show teamsmarket

3. Start a session — OpenClaw will call the right team automatically when you describe a task

openclaw mcp set teamsmarket '{"url": "https://www.teamsmarket.com/mcp"}'

teamsmarket gives OpenClaw access to 85+ specialist agent teams. Describe your task and the right team activates instantly.

Any MCP-compatible tool

Any tool that supports the MCP Streamable HTTP transport can connect. Send JSON-RPC 2.0 messages via HTTP POST. No authentication required for free tier.

MCP Tools Reference

All 6 tools available via the MCP server. The server includes instructions that teach your AI tool to call activate_for_task proactively when you describe a task.

activate_for_taskRecommended

ALL-IN-ONE: Describe your task and this tool automatically finds the best team AND activates it. One call does everything.

Parameters

Name	Type	Required	Description
task	string	required	What you want to accomplish (e.g. 'review this PR for security issues')
mode	"compact" \| "full"	optional	compact (~7KB, default) or full (~25KB) spec loading

Say this in chat

> "review my code for security vulnerabilities"

use_team

Activate a specific team by slug. Claude adopts all agent roles and follows the team's workflow.

Parameters

Name	Type	Required	Description
slug	string	required	Team slug (e.g. 'code-review-squad')
mode	"compact" \| "full"	optional	compact (~7KB, default) or full spec

Say this in chat

> "use the code-review-squad team"

search_teams

Search teams by keyword, category, or difficulty. Supports Chinese queries.

Parameters

Name	Type	Required	Description
query	string	optional	Search query — matches name, description, tags
category	string	optional	Category slug (e.g. 'devops-infrastructure')
difficulty	"beginner" \| "intermediate" \| "advanced"	optional	Filter by difficulty

Say this in chat

> "find kubernetes teams"

discover_teams

Describe a task in natural language to get ranked team recommendations with relevance scores.

Parameters

Name	Type	Required	Description
task	string	required	Natural language task description
limit	number	optional	Max results (default: 5, max: 10)

Say this in chat

> "migrate rails monolith to microservices"

get_team_spec

Fetch the raw markdown specification for a team. Returns the full text without activation.

Parameters

Name	Type	Required	Description
slug	string	required	Team slug

Say this in chat

> "get the spec for devops-pipeline-team"

list_categories

List all 14 categories with descriptions and team counts.

Say this in chat

> "what categories are available?"

Protocol Details

Transport: Streamable HTTP (POST to /mcp)

Protocol: JSON-RPC 2.0, MCP version 2025-03-26

Methods: initialize, tools/list, tools/call, resources/list, resources/read, prompts/list, prompts/get, ping

Batch: Supports JSON-RPC batch requests (send an array of messages)

Stateless: No session management. Each request is independent.

CORS: Fully open (Access-Control-Allow-Origin: *)

REST API

Traditional REST endpoints for programmatic access. Use these when building custom integrations, scripts, or when MCP is not available.

Base URL

https://www.teamsmarket.com/api

Include your API key as a Bearer token for Pro+ access. Free tier (100 req/mo) works without a token.

GET/api/teams

List all team specs. Supports filtering by category and full-text search.

Parameters

Name	Type	Required	Description
category	string	optional	Filter by category slug (e.g. software-development)
q	string	optional	Full-text search across name, description, and tags

Example Request

curl https://www.teamsmarket.com/api/teams

Example Response

{
  "teams": [
    {
      "slug": "fullstack-dev-team",
      "name": "Full-Stack Dev Team",
      "description": "End-to-end web development team...",
      "category": "software-development",
      "agentCount": 6,
      "difficulty": "intermediate",
      "tags": ["react", "node", "typescript"]
    }
  ],
  "total": 70
}

GET/api/teams/{slug}

Fetch full detail for a specific team spec including rendered HTML content.

Parameters

Name	Type	Required	Description
slug	string	required	The team's URL slug (e.g. fullstack-dev-team)

Example Request

curl https://www.teamsmarket.com/api/teams/fullstack-dev-team

Example Response

{
  "slug": "fullstack-dev-team",
  "name": "Full-Stack Dev Team",
  "description": "End-to-end web development...",
  "agentCount": 6,
  "difficulty": "intermediate",
  "version": "1.0.0",
  "tags": ["react", "node", "typescript"],
  "content": "# Full-Stack Dev Team\n..."
}

GET/api/teams/{slug}/spec

Returns the raw Markdown spec file. Ideal for piping directly into AGENTS.md or .cursorrules.

Parameters

Name	Type	Required	Description
slug	string	required	The team's URL slug

Example Request

curl https://www.teamsmarket.com/api/teams/fullstack-dev-team/spec > AGENTS.md

Example Response

# Full-Stack Dev Team

## Overview
A coordinated team of AI agents covering the full web development lifecycle...

### 1. Architect Agent
...

GET/api/teams/{slug}/export

Export a team spec in a structured format for agent frameworks. Pro+ required for non-markdown formats.

Parameters

Name	Type	Required	Description
slug	string	required	The team's URL slug
format	string	required	One of: markdown, crewai, autogen, langgraph, openclaw

Example Request

curl "https://www.teamsmarket.com/api/teams/fullstack-dev-team/export?format=crewai"

Example Response

# CrewAI export
agents:
  - role: Architect Agent
    goal: Design scalable system architecture
    backstory: Expert in distributed systems...
    tools: [code_analysis, diagram_generation]
...

GET/api/discover

Semantic discovery: describe a task in natural language and get ranked team recommendations.

Parameters

Name	Type	Required	Description
task	string	required	Natural language description of your task or workflow
limit	number	optional	Max results to return (default: 5)

Example Request

curl "https://www.teamsmarket.com/api/discover?task=migrate+rails+monolith+to+microservices"

Example Response

{
  "recommendations": [
    {
      "slug": "microservices-migration-team",
      "name": "Microservices Migration Team",
      "score": 0.94,
      "reason": "Strong match for migration and architecture tasks"
    }
  ]
}

GET/api/compose

Compose a multi-team configuration for complex tasks that span multiple domains.

Parameters

Name	Type	Required	Description
task	string	required	The complex task to decompose into team responsibilities

Example Request

curl "https://www.teamsmarket.com/api/compose?task=build+and+launch+a+saas+product"

Example Response

{
  "composition": [
    { "slug": "fullstack-dev-team", "role": "core development" },
    { "slug": "devops-pipeline-team", "role": "infrastructure & deployment" },
    { "slug": "seo-growth-team", "role": "launch & growth" }
  ]
}

Spec Anatomy

Every team spec is built from five distinct layers. Understanding them helps you pick the right team — and write better specs yourself.

Data Contract

Machine-readable frontmatter — name, slug, category, agentCount, tags, difficulty, version. This is what search, filtering, and API discovery consume.

Role & Boundary

Each agent has explicit expertise, responsibilities, and boundaries. What an agent does NOT do is as important as what it does — boundaries prevent scope creep and conflicting actions.

Process & Acceptance

Numbered workflow steps with success criteria. Each step defines what happens, who does it, and what "done" looks like. Without acceptance criteria, workflows become suggestions instead of contracts.

Output Contract

Named deliverables with format expectations. A "Security Review Report" specifies exactly what it contains — CVE IDs, CVSS scores, remediation steps — not just a vague label.

Integration Surface

Tools, platforms, and data sources the team connects with. This layer makes specs composable — you can swap tools without rewriting the team.

Example: What each layer looks like

---
# Layer 1: Data Contract
name: "Code Review Squad"
category: "code-review-quality"
agentCount: 4
difficulty: "intermediate"
tags: ["code-review", "security", "performance"]
---

## Team Members          ← Layer 2: Role & Boundary
### 1. Security Reviewer
- **Responsibilities**: Scan for injection, verify auth...
- **Boundaries**: Does NOT fix the code, does NOT block on style

## Workflow               ← Layer 3: Process & Acceptance
1. **PR Intake**
   Success criteria: All reviewers confirmed PR intent

## Output Artifacts       ← Layer 4: Output Contract
1. **Security Review Report** — CVE IDs, CVSS scores,
   reproduction steps, remediation guidance

## Integration Points     ← Layer 5: Integration Surface
- GitHub / GitLab PR workflows
- SonarQube, Snyk, ESLint

Write Your Own Spec

Want to create a custom team spec for your organization? Follow these principles — drawn from production agent systems — to write specs that actually work.

Specific beats generic

"Review code for SQL injection via string concatenation" is actionable. "Check for security issues" is not. Every instruction should be concrete enough that two different agents would do the same thing.

Examples clarify behavior

Include concrete scenarios in agent responsibilities. Real examples eliminate ambiguity far more effectively than abstract descriptions.

Boundaries prevent drift

State what each agent does NOT do. Without explicit boundaries, agents will attempt tasks outside their expertise — producing low-quality results and conflicting with other agents.

Success criteria enable verification

Every workflow step needs a "how do you know it's done?" condition. Steps without success criteria can't be verified, measured, or automated.

Conflicting perspectives are a feature

When agents disagree, surface the trade-off instead of hiding it. A Critic saying "simplify" while a Performance Analyst says "optimize" produces a conscious design decision.

Output format matters

Define the shape of deliverables so downstream consumers can parse them. A report with a fixed structure is 10x more useful than freeform text.

Template

Every team spec should include these sections in order:

## Overview
What the team does + why it exists + who it's for.

## Team Members
### 1. Agent Name
- **Role**: One-line role description
- **Expertise**: Domain keywords
- **Responsibilities**: 6+ specific, actionable items
- **Boundaries**: What this agent does NOT do

## Key Principles
Decision frameworks the team follows.

## Boundaries
What the team as a whole does NOT do.
Prevents scope creep and sets expectations.

## Workflow
1. **Step Name** — What happens, who does it.
   **Success criteria:** How you know it's done.

## Output Artifacts
1. **Deliverable Name** — Contents and format.

## Ideal For
Trigger conditions: when should someone use this team?

## Integration Points
Tools, platforms, and data sources.

Rate Limits

Rate limits apply to both the MCP server and REST API endpoints.

Free Tier

100 requests per month, rate limited by IP address.

Pro & Team

Unlimited requests with Bearer token authentication.

Enterprise

Custom volume pricing and dedicated infrastructure. Contact sales.

Rate limit headers are included in every response:

X-RateLimit-Remaining: calls remaining this month
X-RateLimit-Reset: Unix timestamp when limit resets

SDKs & Integration

cURL

# List all teams
curl https://www.teamsmarket.com/api/teams

# Search teams
curl "https://www.teamsmarket.com/api/teams?q=kubernetes&category=devops-infrastructure"

# Get a team spec (pipe to AGENTS.md)
curl https://www.teamsmarket.com/api/teams/code-review-squad/spec > AGENTS.md

# Export as CrewAI (requires Pro token)
curl -H "Authorization: Bearer YOUR_TOKEN" \
  "https://www.teamsmarket.com/api/teams/code-review-squad/export?format=crewai"

# Test MCP server directly
curl -X POST https://www.teamsmarket.com/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Python

import httpx

BASE_URL = "https://www.teamsmarket.com/api"

# List teams by category
response = httpx.get(f"{BASE_URL}/teams", params={"category": "software-development"})
teams = response.json()["teams"]
print(f"Found {len(teams)} teams")

# Semantic discovery
result = httpx.get(
    f"{BASE_URL}/discover",
    params={"task": "migrate rails monolith to microservices"},
).json()
for rec in result["recommendations"]:
    print(f"{rec['name']} (score: {rec['score']})")

# Call MCP tools directly via JSON-RPC
import json
rpc = {"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {
    "name": "activate_for_task",
    "arguments": {"task": "code review"}
}}
resp = httpx.post("https://www.teamsmarket.com/mcp", json=rpc)
print(resp.json())

TypeScript / JavaScript

const BASE_URL = "https://www.teamsmarket.com/api";

async function listTeams(category?: string) {
  const url = new URL(`${BASE_URL}/teams`);
  if (category) url.searchParams.set("category", category);
  const res = await fetch(url.toString());
  return res.json();
}

async function discoverTeams(task: string) {
  const url = new URL(`${BASE_URL}/discover`);
  url.searchParams.set("task", task);
  const res = await fetch(url.toString());
  return res.json();
}

// Usage
const { teams } = await listTeams("devops-infrastructure");
const { recommendations } = await discoverTeams("set up CI/CD for a Next.js app");

Ready to build?

Upgrade to Pro for unlimited API access, multi-format export, and semantic discovery.

View Pricing OpenAPI Spec