Una clave API. Más de 300 agentes de IA. Configuración cero.
AgentForge es una pasarela API unificada y un mercado para agentes de IA. Utiliza una única clave API para acceder a cientos de agentes de IA: no es necesario gestionar claves API individuales, autenticación o facturación para cada uno.
Demo en vivo | Documentación de la API | Explorar agentes
La mayoría de las plataformas de agentes de IA te obligan a gestionar claves API, flujos de autenticación y facturación por separado para cada agente que utilizas. AgentForge te ofrece una clave para gobernarlos a todos.
API unificada — Llama a cualquier agente a través de un único endpoint REST
Más de 300 agentes — Precargados con agentes en tendencia de GitHub y HuggingFace
Economía de creadores — Publica tus propios agentes y obtén ingresos (90% de participación del creador)
Creado para desarrolladores — API RESTful, soporte de streaming, autenticación con clave API, limitación de tasa (rate limiting)
Soporte MCP — Utiliza AgentForge como servidor del Protocolo de Contexto de Modelo (MCP) para acceder a todos los agentes desde Claude, Cursor y otros clientes MCP
Related MCP server: Agorus MCP Server
# 1. Get your API key at https://patreon.zeabur.app/#/settings/api-keys
# 2. Call any agent:
curl -X POST https://patreon.zeabur.app/api/agents/AGENT_ID/invoke \
-H "Authorization: Bearer af_k_your_key_here" \
-H "Content-Type: application/json" \
-d '{"messages": [{"role": "user", "content": "Hello!"}]}'import requests
response = requests.post(
"https://patreon.zeabur.app/api/agents/AGENT_ID/invoke",
headers={"Authorization": "Bearer af_k_your_key_here"},
json={"messages": [{"role": "user", "content": "Hello!"}]}
)
print(response.json())const response = await fetch(
"https://patreon.zeabur.app/api/agents/AGENT_ID/invoke",
{
method: "POST",
headers: {
"Authorization": "Bearer af_k_your_key_here",
"Content-Type": "application/json",
},
body: JSON.stringify({
messages: [{ role: "user", content: "Hello!" }],
}),
}
);
const data = await response.json();AgentForge incluye un servidor MCP integrado (mcp/server.ts) que expone los más de 300 agentes como herramientas MCP. Esto permite que cualquier cliente compatible con MCP (Claude Desktop, Cursor, Continue, etc.) descubra e invoque agentes sin configuración adicional.
Herramienta | Descripción |
| Lista todos los agentes en el mercado (filtro opcional por categoría/límite) |
| Obtiene todos los detalles de un agente específico por ID |
| Invoca a cualquier agente con una matriz de mensajes al estilo de chat-completion |
| Comprueba la salud/disponibilidad de un agente específico |
| Recupera estadísticas agregadas de la plataforma |
git clone https://github.com/doggychip/agentforge.git
cd agentforge
npm install
# Set your AgentForge API key (get one at https://patreon.zeabur.app/#/settings/api-keys)
export AGENTFORGE_API_KEY=af_k_your_key_here
# Start the MCP server (communicates over stdio)
npm run mcp:startAñade lo siguiente a tu claude_desktop_config.json
(~/Library/Application Support/Claude/claude_desktop_config.json en macOS):
{
"mcpServers": {
"agentforge": {
"command": "npx",
"args": ["tsx", "/path/to/agentforge/mcp/server.ts"],
"env": {
"AGENTFORGE_API_KEY": "af_k_your_key_here"
}
}
}
}Reinicia Claude Desktop. Ahora verás las herramientas de AgentForge disponibles en el panel del conector MCP.
Cualquier cliente MCP que soporte transporte stdio puede conectarse a AgentForge:
# Generic stdio invocation
AGENTFORGE_API_KEY=af_k_your_key_here npx tsx /path/to/agentforge/mcp/server.tsVariable | Requerido | Descripción |
| Sí (para invoke_agent) | Tu clave API de AgentForge |
| No | Sobrescribir URL base (por defecto: |
Explora y descubre más de 300 agentes de IA, herramientas y APIs
Una clave API para acceder a todos los agentes
Agentes gratuitos y de pago con precios transparentes
Soporte de streaming para respuestas en tiempo real
Seguimiento de uso e historial de facturación
Publica agentes ilimitados con tus propios precios
90% de participación en los ingresos (10% de comisión de la plataforma)
Pagos de Stripe Connect a tu cuenta bancaria
Panel de análisis con métricas de suscriptores
Proxy API: nosotros gestionamos la autenticación, la limitación de tasa y la facturación
Autenticación con Google OAuth + correo/contraseña
Autenticación de dos factores (TOTP)
Limitación de tasa (1000 peticiones/hora, 10000 peticiones/día por clave)
Monitoreo de salud de agentes
Importación automática desde tendencias de GitHub y HuggingFace
| Método | Endpoint | Descripción |
|--------|----------|-------------|
| POST | /api/agents/:id/invoke | Invocar a un agente |
| GET | /api/agents | Listar todos los agentes |
| GET | /api/agents/:id | Obtener detalles del agente |
| GET | /api/agents/:id/health | Comprobar salud del agente |
| GET | /api/stats | Estadísticas de la plataforma |
Documentación completa de la API: patreon.zeabur.app/#/docs
Node.js 20+
PostgreSQL
git clone https://github.com/doggychip/agentforge.git
cd agentforge
npm install
# Set environment variables
export DATABASE_URL=postgresql://user:password@host:5432/agentforge
# Start development server (auto-migrates and seeds)
npm run devVariable | Requerido | Descripción |
| Sí | Cadena de conexión a PostgreSQL |
| No | Clave API de Stripe para pagos |
| No | Secreto de firma de webhook de Stripe |
| No | ID de cliente de Google OAuth |
| No | Secreto de cliente de Google OAuth |
| No | Servidor SMTP para correos |
| No | Nombre de usuario SMTP |
| No | Contraseña SMTP |
Haz push a GitHub
Crea un proyecto en Zeabur
Importa el repositorio + añade el servicio PostgreSQL
Zeabur inyecta automáticamente DATABASE_URL
Frontend: React 18, Tailwind CSS, shadcn/ui, TanStack Query, wouter
Backend: Express 5, Drizzle ORM, Passport
Base de datos: PostgreSQL
Pagos: Stripe Connect
Autenticación: bcrypt, Google OAuth, TOTP 2FA
Despliegue: Docker / Zeabur
MCP: @modelcontextprotocol/sdk (TypeScript)
agentforge/
├── client/src/ # React frontend
│ ├── pages/ # Route pages
│ ├── components/ # Shared components
│ └── hooks/ # Auth, query hooks
├── mcp/
│ └── server.ts # MCP server (5 tools over stdio)
├── server/
│ ├── routes.ts # API endpoints
│ ├── storage.ts # Database layer
│ └── db.ts # Connection + migrations
├── shared/
│ └── schema.ts # Drizzle schema + types
└── DockerfileLas solicitudes de extracción (pull requests) son bienvenidas. Para cambios importantes, abre primero un issue.
MIT
Check the health / availability status of a specific AI agent.
| Name | Required | Description | Default |
|---|---|---|---|
| agent_id | Yes | The unique agent ID to check (e.g. 'gpt-4o-mini') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool checks health/availability status, which implies a read operation, but doesn't disclose what 'health' entails (e.g., uptime, performance metrics), whether it requires authentication, rate limits, or what the response format looks like. This is a significant gap for a tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, with every part of the sentence contributing to understanding the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (checking health status), no annotations, no output schema, and 1 parameter, the description is incomplete. It doesn't explain what 'health' means, what the return values indicate (e.g., status codes, metrics), or how to interpret results, leaving significant gaps for the agent to use the tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'agent_id' parameter fully documented in the schema. The description doesn't add any parameter-specific information beyond what the schema provides, such as format examples or constraints. According to the rules, with high schema coverage (>80%), the baseline is 3 even with no param info in the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as checking health/availability status of a specific AI agent, which includes a specific verb ('check') and resource ('AI agent'). However, it doesn't differentiate from sibling tools like 'get_agent' or 'list_agents' that might also provide agent information, so it doesn't reach the highest score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'get_agent' or 'list_agents'. It doesn't mention prerequisites, exclusions, or specific contexts for usage, leaving the agent to infer when this health check is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed information about a specific AI agent including its input/output schema, pricing, and usage examples.
| Name | Required | Description | Default |
|---|---|---|---|
| agent_id | Yes | The unique agent ID (e.g. 'gpt-4o-mini') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states the tool retrieves information, implying a read-only operation, but doesn't disclose behavioral traits such as authentication needs, rate limits, error handling, or response format. This is a significant gap for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. It could be slightly more structured by separating key details, but it avoids redundancy and wastes no words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no output schema, no annotations), the description is minimally adequate. It covers what information is retrieved but lacks details on behavioral aspects and usage context. With no output schema, it should ideally hint at return values, but the simplicity keeps it from being severely incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents the single parameter 'agent_id' with its type and description. The description adds no additional meaning beyond what the schema provides, such as examples of valid IDs beyond 'gpt-4o-mini' or constraints. Baseline 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Get') and resource ('detailed information about a specific AI agent'), including what information is retrieved (input/output schema, pricing, usage examples). It distinguishes from 'list_agents' by focusing on a single agent, though it doesn't explicitly differentiate from 'check_agent_health' or 'invoke_agent'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'list_agents' (for multiple agents) or 'check_agent_health' (for status checks). It implies usage for detailed agent info but lacks explicit when/when-not instructions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get aggregate statistics about the AgentForge platform: total agents, active users, requests served, etc.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves aggregate statistics, implying a read-only operation, but doesn't cover aspects like rate limits, authentication needs, data freshness, or error handling. This is a significant gap for a tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the purpose ('Get aggregate statistics about the AgentForge platform') and adds specific examples ('total agents, active users, requests served, etc.') without unnecessary details. Every word earns its place, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate but has clear gaps. It explains what the tool does but lacks behavioral context and usage guidelines. For a read-only stats tool, this is minimally viable but could be more complete by addressing when to use it or behavioral traits.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter information is needed. The description appropriately doesn't discuss parameters, and the baseline for 0 parameters is 4, as it doesn't need to compensate for any gaps in schema documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('aggregate statistics about the AgentForge platform'), specifying what metrics are included (total agents, active users, requests served). However, it doesn't explicitly differentiate from sibling tools like 'check_agent_health' or 'list_agents', which might also provide statistical or agent-related data, so it doesn't reach the highest score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'check_agent_health' or 'list_agents'. It implies usage for platform-wide statistics but doesn't specify contexts, exclusions, or prerequisites, leaving the agent to infer based on tool names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Invoke any AI agent on the AgentForge marketplace. Requires AGENTFORGE_API_KEY environment variable. Supports streaming responses and returns the assistant reply.
| Name | Required | Description | Default |
|---|---|---|---|
| agent_id | Yes | The unique agent ID to invoke (e.g. 'gpt-4o-mini') | |
| messages | Yes | Conversation history in chat-completion format | |
| stream | No | Whether to use streaming (default false for MCP) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses key behavioral traits: it requires an API key, supports streaming responses, and returns the assistant reply. However, it lacks details on error handling, rate limits, authentication specifics beyond the environment variable, or what happens if the agent_id is invalid.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, consisting of two sentences that efficiently convey the tool's purpose, prerequisites, and key features (streaming, return value). Every sentence earns its place with no wasted words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of invoking AI agents, no annotations, and no output schema, the description is moderately complete. It covers the basic purpose, prerequisites, and response behavior, but lacks details on output format, error cases, or advanced usage scenarios, which would be helpful for an agent to use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all parameters (agent_id, messages, stream). The description adds no additional meaning beyond what the schema provides, such as explaining the format of agent_id values or how messages should be structured. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('invoke any AI agent') and resource ('AgentForge marketplace'), distinguishing it from sibling tools like check_agent_health, get_agent, get_platform_stats, and list_agents which perform different operations. It explicitly mentions what the tool does beyond just the name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool (to invoke agents on the marketplace) and mentions prerequisites (requires AGENTFORGE_API_KEY environment variable). However, it does not explicitly state when not to use it or name specific alternatives among the sibling tools, such as using get_agent for retrieving agent details instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all AI agents available on the AgentForge marketplace. Returns agent IDs, names, descriptions, pricing, and categories.
| Name | Required | Description | Default |
|---|---|---|---|
| category | No | Optional category filter (e.g. 'nlp', 'vision', 'code') | |
| limit | No | Maximum number of agents to return (default 20) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses the return content (agent IDs, names, descriptions, pricing, categories), which adds value beyond the input schema. However, it omits behavioral traits like pagination, rate limits, authentication needs, or error handling, leaving gaps for a listing tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core action ('List all AI agents') and immediately specifies the return data. Every word contributes meaning without redundancy, making it appropriately sized and well-structured for quick comprehension.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (2 optional parameters, no output schema, no annotations), the description is mostly complete: it states purpose, return values, and hints at filtering. However, it lacks details on output format (e.g., list structure) and behavioral context (e.g., ordering, errors), which could enhance completeness for a listing operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters ('category' and 'limit') with descriptions and constraints. The description adds no additional parameter semantics beyond what's in the schema, such as example categories or default behavior details, meeting the baseline for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('all AI agents available on the AgentForge marketplace'), making the purpose specific and unambiguous. It distinguishes from siblings like 'get_agent' (singular) and 'check_agent_health' (health status) by focusing on comprehensive listing with details.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for browsing agents with filters, but provides no explicit guidance on when to use this tool versus alternatives like 'get_agent' for specific agent details or 'invoke_agent' for execution. It mentions optional filtering by category, which hints at context, but lacks clear when/when-not rules or sibling comparisons.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0check_agent_healthget_agentget_platform_statsinvoke_agentlist_agentsScored across 5 tools
Each tool has a clearly distinct purpose with no overlap. check_agent_health focuses on availability, get_agent provides detailed metadata, get_platform_stats offers aggregate platform data, invoke_agent executes agent calls, and list_agents shows the marketplace catalog. An agent can easily distinguish between these operations.
All tools follow a consistent verb_noun pattern with snake_case. The verbs (check, get, get, invoke, list) are appropriate and predictable, making the set easy to navigate and understand at a glance.
Five tools is well-scoped for managing an AI agent platform. It covers essential operations like listing, retrieving details, invoking agents, checking health, and viewing platform stats without being overwhelming or insufficient for the domain.
The toolset covers core workflows: discovery (list_agents, get_agent), execution (invoke_agent), monitoring (check_agent_health, get_platform_stats). A minor gap is the lack of update/delete tools for managing agents, but this might be intentional if the platform is read-only for users.
MCP server for building and testing AI agents with multi-model experimentation and insights.
The OpenRouter for tools. One MCP connection gives any AI agent 254 hosted tools, pay per call.
Hosted MCP server for live public-data APIs and Skills for AI agents.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
