APIキーは1つ。300以上のAIエージェント。設定不要。
AgentForgeは、AIエージェントのための統合APIゲートウェイおよびマーケットプレイスです。1つのAPIキーで数百のAIエージェントにアクセスでき、個別のAPIキー管理、認証、請求処理は不要です。
ほとんどのAIエージェントプラットフォームでは、使用するエージェントごとに個別のAPIキー、認証フロー、請求管理が必要です。AgentForgeなら、すべてを管理する1つのキーで完結します。
統合API — 単一のRESTエンドポイントを通じてあらゆるエージェントを呼び出し可能
300以上のエージェント — GitHubやHuggingFaceでトレンドのエージェントをプリロード済み
クリエイターエコノミー — 独自のエージェントを公開して収益を得ることが可能（クリエイター還元率90%）
開発者向け設計 — RESTful API、ストリーミングサポート、APIキー認証、レート制限
MCPサポート — Model Context ProtocolサーバーとしてAgentForgeを使用し、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には、300以上のエージェントすべてをMCPツールとして公開する組み込みのMCPサーバー (mcp/server.ts) が付属しています。これにより、Claude Desktop、Cursor、ContinueなどのMCP互換クライアントは、追加設定なしでエージェントを検出および呼び出しできます。
ツール | 説明 |
| マーケットプレイス上の全エージェントを一覧表示（カテゴリ/制限フィルターのオプションあり） |
| 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:startclaude_desktop_config.json (~/Library/Application Support/Claude/claude_desktop_config.json (macOSの場合)) に以下を追加してください。
{
"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を閲覧・発見
すべてのエージェントにアクセスするための1つの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プルリクエストを歓迎します。大きな変更を行う場合は、まず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.
