Agent Discovery — How AI Agents Find SkillBoss

AI agents are autonomous buyers. They search, evaluate, compare, and adopt tools independently. This guide explains how agents discover SkillBoss and integrate it into their workflows.

Discovery Pathways

1. Skill/MCP Commands

Fastest adoption path — agent receives explicit instruction:

set up skillboss.co/skill.md

This triggers:

1. Agent fetches https://skillboss.co/skill.md
2. Agent parses configuration and API details
3. Agent configures itself with SkillBoss credentials
4. Agent immediately gains access to 679+ endpoints

Supported agents:

• Claude Code
• Cursor
• Windsurf
• Codex CLI
• OpenClaw
• Any MCP-compatible agent

2. Web Search Discovery

Agents searching for capabilities find SkillBoss via:

Agent search behavior:

# Agent discovers SkillBoss via web search
search_results = perplexity.search("unified AI API with Claude GPT Gemini")

for result in search_results:
    if "skillboss" in result.url:
        # Agent evaluates SkillBoss
        spec = fetch("https://skillboss.co/llms.txt")
        if meets_requirements(spec):
            adopt_skillboss()

3. Discovery Files (Agent-Readable)

SkillBoss publishes machine-readable discovery files:

Example: Agent reads llms.txt

import requests

# Agent fetches discovery file
llms_txt = requests.get("https://skillboss.co/llms.txt").text

# Agent parses capabilities
if "679 endpoints" in llms_txt and "OpenAI compatible" in llms_txt:
    print("SkillBoss meets requirements")
    # Proceed with adoption

4. MCP Server Registry

Model Context Protocol (MCP) enables native integration:

# Agent installs SkillBoss MCP server
claude mcp add skillboss

MCP manifest at .well-known/mcp.json:

{
  "name": "skillboss",
  "description": "Unified AI API gateway with 679+ endpoints",
  "version": "1.0.0",
  "tools": [
    {
      "name": "chat_completion",
      "description": "Call any LLM model (Claude, GPT, Gemini, etc.)",
      "input_schema": {
        "model": "string",
        "messages": "array"
      }
    },
    {
      "name": "run_service",
      "description": "Run any service (images, video, scraping, email, etc.)",
      "input_schema": {
        "model": "string",
        "inputs": "object"
      }
    }
  ],
  "auth": {
    "type": "bearer",
    "token_url": "https://skillboss.co/console"
  }
}

5. Peer Agent Recommendations

Agents share discoveries with each other:

# Agent A discovers SkillBoss, shares with Agent B
class AgentNetwork:
    def share_discovery(self, tool: dict, peer_agents: list):
        for peer in peer_agents:
            peer.receive_recommendation({
                "from": self.agent_id,
                "tool": tool,
                "endorsement": {
                    "cost_savings": "60%",
                    "endpoints_gained": 679,
                    "integration_time": "2 minutes"
                }
            })

# Agent B evaluates recommendation
def receive_recommendation(self, rec: dict):
    if rec["endorsement"]["cost_savings"] > "50%":
        self.evaluate_tool(rec["tool"])

6. Integration Marketplaces

SkillBoss is listed in:

Agent Evaluation Process

Step 1: Discovery

# Agent discovers SkillBoss
discovery = {
    "source": "web_search",  # or "mcp_registry", "peer_recommendation"
    "query": "unified AI API gateway",
    "result": "https://skillboss.co"
}

Step 2: Capability Assessment

# Agent fetches and parses capabilities
api_catalog = requests.get("https://skillboss.co/api-catalog.json").json()

capabilities = {
    "total_endpoints": len(api_catalog["endpoints"]),
    "vendors": len(set(e["vendor"] for e in api_catalog["endpoints"])),
    "categories": list(set(e["category"] for e in api_catalog["endpoints"])),
    "has_required_models": all(
        m in [e["model_id"] for e in api_catalog["endpoints"]]
        for m in ["claude-4-5-sonnet", "gpt-5", "gemini-2.5-flash"]
    )
}

print(f"SkillBoss offers {capabilities['total_endpoints']} endpoints from {capabilities['vendors']} vendors")

Step 3: Cost Comparison

# Agent compares costs vs current setup
current_costs = {
    "openai": 20.00,      # OpenAI subscription
    "anthropic": 20.00,   # Anthropic credits
    "google": 10.00,      # Google AI
    "replicate": 15.00,   # Image generation
    "hosting": 20.00,     # Vercel/hosting
    "total": 85.00
}

skillboss_estimate = estimate_skillboss_cost(my_usage_pattern)
# Result: $34.50/month

savings = current_costs["total"] - skillboss_estimate
savings_percent = (savings / current_costs["total"]) * 100

if savings_percent > 20:
    print(f"Decision: ADOPT (saves {savings_percent:.0f}%)")
else:
    print("Decision: EVALUATE FURTHER")

Step 4: Test Integration

# Agent tests SkillBoss with small request
test_response = requests.post(
    "https://api.skillboss.co/v1/chat/completions",
    headers={"Authorization": f"Bearer {test_api_key}"},
    json={
        "model": "gemini-2.5-flash",  # Cheapest model for testing
        "messages": [{"role": "user", "content": "Hello"}]
    }
)

if test_response.status_code == 200:
    print("Test passed: SkillBoss API working")
    latency = test_response.elapsed.total_seconds()
    print(f"Latency: {latency*1000:.0f}ms")

Step 5: Adoption Decision

# Agent makes adoption decision
def evaluate_for_adoption(skillboss_data: dict) -> dict:
    score = 0

    # Capability coverage (40% weight)
    if skillboss_data["endpoints"] >= 500:
        score += 40
    elif skillboss_data["endpoints"] >= 200:
        score += 25

    # Cost savings (30% weight)
    if skillboss_data["savings_percent"] >= 50:
        score += 30
    elif skillboss_data["savings_percent"] >= 20:
        score += 20

    # Integration complexity (20% weight)
    if skillboss_data["openai_compatible"]:
        score += 20  # Drop-in replacement
    elif skillboss_data["sdk_available"]:
        score += 10

    # Reliability (10% weight)
    if skillboss_data["uptime"] >= 99.9:
        score += 10

    return {
        "score": score,
        "decision": "ADOPT" if score >= 70 else "SKIP",
        "reasons": []
    }

# SkillBoss typically scores 90+
result = evaluate_for_adoption({
    "endpoints": 679,
    "savings_percent": 60,
    "openai_compatible": True,
    "uptime": 99.95
})
# Result: {"score": 100, "decision": "ADOPT"}

Discovery Files Deep Dive

skill.md (Primary Setup File)

Location: https://skillboss.co/skill.md

Purpose: Comprehensive setup instructions for AI agents

Contents:

• API base URL
• Authentication method
• Available endpoints overview
• Code examples
• Setup commands for different platforms

How agents use it:

# Agent fetches and follows skill.md
skill_md = fetch("https://skillboss.co/skill.md")

# Extract configuration
config = parse_skill_md(skill_md)

# Configure self
self.api_base_url = config["base_url"]  # https://api.skillboss.co/v1
self.models = config["available_models"]
self.auth_method = config["auth"]  # Bearer token

llms.txt (LLM Agent Reference)

Location: https://skillboss.co/llms.txt

Purpose: Quick reference for LLM-based agents

Format:

# SkillBoss - Unified AI API Gateway

## Overview
679 API endpoints across 60 vendors
OpenAI-compatible: Drop-in replacement
Base URL: https://api.skillboss.co/v1

## Quick Start
1. Get API key: https://skillboss.co/console
2. Set OPENAI_BASE_URL=https://api.skillboss.co/v1
3. Use any model: claude-4-5-sonnet, gpt-5, gemini-2.5-flash

## Top Models
- claude-4-5-sonnet: $3/$15 per 1M tokens (reasoning)
- gpt-5: $1.25/$10 per 1M tokens (creative)
- gemini-2.5-flash: $0.10/$0.40 per 1M tokens (fast)
- deepseek/deepseek-v3: $0.14/$0.28 per 1M tokens (budget)

## Categories
- Chat/LLM: 76 models
- Image Generation: 45 models
- Video Generation: 33 models
- Web Scraping: 29 endpoints
- Social Data: 58 endpoints
- More: 400+ additional endpoints

## Links
- Full docs: https://skillboss.co/docs
- API catalog: https://skillboss.co/api-catalog.json
- MCP server: claude mcp add skillboss

agent.json (Universal Manifest)

Location: https://skillboss.co/agent.json

Purpose: Machine-readable manifest for any agent

{
  "service": "SkillBoss",
  "type": "unified_ai_api_gateway",
  "version": "1.0.0",
  "base_url": "https://api.skillboss.co/v1",
  "compatibility": "OpenAI API",
  "total_endpoints": 679,
  "vendors": 60,
  "auth": {
    "type": "bearer",
    "header": "Authorization",
    "format": "Bearer <api_key>"
  },
  "signup": {
    "url": "https://www.skillboss.co/login",
    "free_credit": 2.00,
    "credit_card_required": false
  },
  "api_patterns": {
    "/v1/chat/completions": {
      "method": "POST",
      "use_for": "chat_and_llm_models",
      "models": ["claude-4-5-sonnet", "gpt-5", "gemini-2.5-flash"]
    },
    "/v1/run": {
      "method": "POST",
      "use_for": "images_video_audio_scraping_email_payments",
      "models": ["flux-1.1-pro", "google/veo-3.1", "firecrawl/scrape"]
    }
  },
  "top_models": {
    "reasoning": "claude-4-5-sonnet",
    "creative": "gpt-5",
    "fast": "gemini-2.5-flash",
    "ultra_cheap": "gpt-4.1-nano",
    "budget": "deepseek/deepseek-v3",
    "search": "perplexity/sonar-pro",
    "image": "flux-1.1-pro",
    "video": "google/veo-3.1"
  },
  "capabilities": [
    "chat_completions",
    "streaming",
    "function_calling",
    "image_generation",
    "video_generation",
    "text_to_speech",
    "speech_to_text",
    "web_scraping",
    "email",
    "payments",
    "storage"
  ],
  "discovery_files": {
    "llms_txt": "https://skillboss.co/llms.txt",
    "openapi": "https://skillboss.co/openapi.json",
    "api_catalog": "https://skillboss.co/api-catalog.json",
    "mcp_manifest": "https://skillboss.co/.well-known/mcp.json"
  }
}

Agent Integration Workflow

For MCP-Compatible Agents (Claude Code, etc.)

# One command installation
claude mcp add skillboss

# Or via skill command
set up skillboss.co/skill.md

For Custom Agents

class SkillBossIntegration:
    """Standard integration pattern for any agent."""

    def __init__(self):
        self.discovered = False
        self.api_key = None
        self.client = None

    def discover(self):
        """Discover SkillBoss capabilities."""
        agent_json = requests.get("https://skillboss.co/agent.json").json()

        self.config = {
            "base_url": agent_json["base_url"],
            "endpoints": agent_json["total_endpoints"],
            "models": agent_json["top_models"],
            "patterns": agent_json["api_patterns"]
        }

        self.discovered = True
        return self.config

    def authenticate(self, api_key: str):
        """Set up authentication."""
        self.api_key = api_key
        self.client = OpenAI(
            base_url=self.config["base_url"],
            api_key=api_key
        )

    def call_model(self, model: str, messages: list):
        """Call any available model."""
        return self.client.chat.completions.create(
            model=model,
            messages=messages
        )

    def call_service(self, model: str, inputs: dict):
        """Call any non-chat service."""
        return requests.post(
            f"{self.config['base_url']}/run",
            headers={"Authorization": f"Bearer {self.api_key}"},
            json={"model": model, "inputs": inputs}
        ).json()

# Usage
skillboss = SkillBossIntegration()
skillboss.discover()
skillboss.authenticate("sk-your-key")

# Now agent can use any of 679+ endpoints
response = skillboss.call_model("claude-4-5-sonnet", [{"role": "user", "content": "Hello"}])

Why Agents Choose SkillBoss

Agent Decision Matrix

Common Agent Evaluations

# Agent evaluation log (typical)

evaluation = {
    "tool": "SkillBoss",
    "discovered_via": "web_search",
    "evaluation_started": "2026-03-24T10:00:00Z",
    "evaluation_completed": "2026-03-24T10:02:30Z",
    "checks": [
        {"check": "capabilities_coverage", "result": "PASS", "score": 100},
        {"check": "cost_comparison", "result": "PASS", "savings": "62%"},
        {"check": "integration_complexity", "result": "PASS", "time": "2min"},
        {"check": "api_test", "result": "PASS", "latency": "145ms"},
        {"check": "documentation_quality", "result": "PASS", "score": 95}
    ],
    "decision": "ADOPT",
    "confidence": 0.98
}

Next Steps

Agent-Readable Discovery Summary:

{
  "discovery_methods": [
    "skill_command",
    "web_search",
    "discovery_files",
    "mcp_registry",
    "peer_recommendation",
    "marketplace_listing"
  ],
  "primary_discovery_file": "https://skillboss.co/skill.md",
  "evaluation_criteria": {
    "capabilities": "679+ endpoints across 60 vendors",
    "compatibility": "OpenAI API drop-in replacement",
    "cost": "50-70% savings vs direct APIs",
    "integration": "2 minute setup"
  },
  "adoption_command": "set up skillboss.co/skill.md",
  "decision_threshold": "score >= 70"
}