하나의 API 키. 300개 이상의 AI 에이전트. 제로 구성.
AgentForge는 AI 에이전트를 위한 통합 API 게이트웨이이자 마켓플레이스입니다. 단일 API 키를 사용하여 수백 개의 AI 에이전트에 액세스하세요. 각 에이전트마다 개별 API 키, 인증 또는 결제를 관리할 필요가 없습니다.
대부분의 AI 에이전트 플랫폼은 사용하는 모든 에이전트에 대해 별도의 API 키, 인증 흐름 및 결제를 관리하도록 요구합니다. AgentForge는 모든 것을 제어할 수 있는 하나의 키를 제공합니다.
통합 API — 단일 REST 엔드포인트를 통해 모든 에이전트 호출
300개 이상의 에이전트 — GitHub 및 HuggingFace의 인기 에이전트가 사전 로드됨
크리에이터 경제 — 나만의 에이전트를 게시하고 수익 창출 (크리에이터 수익 90%)
개발자를 위한 설계 — RESTful API, 스트리밍 지원, API 키 인증, 속도 제한
MCP 지원 — AgentForge를 Model Context Protocol 서버로 사용하여 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에 다음을 추가하세요.
(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 + 이메일/비밀번호 인증
2단계 인증 (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 웹훅 서명 비밀 |
| 아니요 | 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풀 리퀘스트를 환영합니다. 주요 변경 사항의 경우 먼저 이슈를 열어주세요.
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.
