一个 API 密钥。300+ AI 智能体。零配置。
AgentForge 是一个统一的 AI 智能体 API 网关和市场。使用单个 API 密钥即可访问数百个 AI 智能体——无需为每个智能体管理单独的 API 密钥、身份验证或计费。
大多数 AI 智能体平台要求你为使用的每个智能体管理单独的 API 密钥、身份验证流程和计费。AgentForge 为你提供一个密钥，掌控一切。
统一 API — 通过单个 REST 端点调用任何智能体
300+ 智能体 — 预装了来自 GitHub 和 HuggingFace 的热门智能体
创作者经济 — 发布你自己的智能体并赚取收入（创作者分成 90%）
为开发者打造 — RESTful API、流式传输支持、API 密钥认证、速率限制
MCP 支持 — 将 AgentForge 用作模型上下文协议 (MCP) 服务器，从 Claude、Cursor 和其他 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 内置了一个 MCP 服务器 (mcp/server.ts)，将所有 300 多个智能体作为 MCP 工具公开。这使得任何兼容 MCP 的客户端（Claude Desktop、Cursor、Continue 等）无需额外配置即可发现并调用智能体。
工具 | 描述 |
| 列出市场上的所有智能体（可选分类/限制过滤器） |
| 通过 ID 获取特定智能体的详细信息 |
| 使用聊天补全风格的消息数组调用任何智能体 |
| 检查特定智能体的健康状况/可用性 |
| 检索平台汇总统计信息 |
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:start将以下内容添加到你的 claude_desktop_config.json 中
（macOS 上位于 ~/Library/Application Support/Claude/claude_desktop_config.json）：
{
"mcpServers": {
"agentforge": {
"command": "npx",
"args": ["tsx", "/path/to/agentforge/mcp/server.ts"],
"env": {
"AGENTFORGE_API_KEY": "af_k_your_key_here"
}
}
}
}重启 Claude Desktop。你现在将在 MCP 连接器面板中看到可用的 AgentForge 工具。
任何支持 stdio 传输的 MCP 客户端都可以连接到 AgentForge：
# Generic stdio invocation
AGENTFORGE_API_KEY=af_k_your_key_here npx tsx /path/to/agentforge/mcp/server.ts变量 | 必需 | 描述 |
| 是（用于 invoke_agent） | 你的 AgentForge API 密钥 |
| 否 | 覆盖基础 URL（默认： |
浏览并发现 300 多个 AI 智能体、工具和 API
一个 API 密钥即可访问所有智能体
免费和付费智能体，定价透明
支持实时响应的流式传输
使用情况跟踪和计费历史记录
发布无限数量的智能体并设置你自己的定价
90% 收入分成（10% 平台费用）
通过 Stripe Connect 支付到你的银行账户
包含订阅者指标的分析仪表板
API 代理 — 我们处理身份验证、速率限制和计费
Google OAuth + 电子邮件/密码身份验证
双重身份验证 (TOTP)
速率限制（每密钥每小时 1000 次请求，每天 10000 次请求）
智能体健康监控
从 GitHub 热门和 HuggingFace 自动导入
| 方法 | 端点 | 描述 |
|--------|----------|-------------|
| POST | /api/agents/:id/invoke | 调用智能体 |
| GET | /api/agents | 列出所有智能体 |
| GET | /api/agents/:id | 获取智能体详情 |
| GET | /api/agents/:id/health | 检查智能体健康状况 |
| GET | /api/stats | 平台统计信息 |
完整 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 dev变量 | 必需 | 描述 |
| 是 | PostgreSQL 连接字符串 |
| 否 | 用于支付的 Stripe API 密钥 |
| 否 | Stripe Webhook 签名密钥 |
| 否 | Google OAuth 客户端 ID |
| 否 | Google OAuth 客户端密钥 |
| 否 | 用于电子邮件的 SMTP 服务器 |
| 否 | SMTP 用户名 |
| 否 | SMTP 密码 |
推送到 GitHub
在 Zeabur 中创建项目
导入仓库 + 添加 PostgreSQL 服务
Zeabur 会自动注入 DATABASE_URL
前端：React 18, Tailwind CSS, shadcn/ui, TanStack Query, wouter
后端：Express 5, Drizzle ORM, Passport
数据库：PostgreSQL
支付：Stripe Connect
认证：bcrypt, Google OAuth, TOTP 2FA
部署：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
└── Dockerfile欢迎提交 Pull Request。对于重大更改，请先开启一个 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.
