Integrates with GitHub to auto-import trending AI agents from GitHub repositories, expanding the available agent marketplace.
Provides Google OAuth authentication for user accounts and Google OAuth client integration for platform authentication.
Uses PostgreSQL as the primary database for storing user data, agent information, billing records, and platform statistics.
Enables payment processing for paid agents through Stripe Connect, handling billing, payouts to creators, and subscription management.
One API key. 300+ AI agents. Zero configuration.
AgentForge is a unified API gateway and marketplace for AI agents. Use a single API key to access hundreds of AI agents — no need to manage individual API keys, authentication, or billing for each one.
Live Demo | API Docs | Browse Agents
Most AI agent platforms make you manage separate API keys, auth flows, and billing for every agent you use. AgentForge gives you one key to rule them all.
Unified API — Call any agent through a single REST endpoint
300+ agents — Pre-loaded with trending agents from GitHub and HuggingFace
Creator economy — Publish your own agents and earn revenue (90% creator share)
Built for developers — RESTful API, streaming support, API key auth, rate limiting
MCP support — Use AgentForge as a Model Context Protocol server to access all agents from Claude, Cursor, and other MCP clients
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 ships a built-in MCP server (mcp/server.ts) that exposes all 300+ agents as MCP tools. This lets any MCP-compatible client — Claude Desktop, Cursor, Continue, etc. — discover and invoke agents with zero extra configuration.
Tool | Description |
| List all agents on the marketplace (optional category/limit filter) |
| Get full details for a specific agent by ID |
| Invoke any agent with a chat-completion style messages array |
| Check the health/availability of a specific agent |
| Retrieve aggregate platform statistics |
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:startAdd the following to your claude_desktop_config.json
(~/Library/Application Support/Claude/claude_desktop_config.json on macOS):
{
"mcpServers": {
"agentforge": {
"command": "npx",
"args": ["tsx", "/path/to/agentforge/mcp/server.ts"],
"env": {
"AGENTFORGE_API_KEY": "af_k_your_key_here"
}
}
}
}Restart Claude Desktop. You will now see AgentForge tools available in the MCP connector panel.
Any MCP client that supports stdio transport can connect to AgentForge:
# Generic stdio invocation
AGENTFORGE_API_KEY=af_k_your_key_here npx tsx /path/to/agentforge/mcp/server.tsVariable | Required | Description |
| Yes (for invoke_agent) | Your AgentForge API key |
| No | Override base URL (default: |
Browse and discover 300+ AI agents, tools, and APIs
One API key to access all agents
Free and paid agents with transparent pricing
Streaming support for real-time responses
Usage tracking and billing history
Publish unlimited agents with your own pricing
90% revenue share (10% platform fee)
Stripe Connect payouts to your bank account
Analytics dashboard with subscriber metrics
API proxy — we handle auth, rate limiting, and billing
Google OAuth + email/password authentication
Two-factor authentication (TOTP)
Rate limiting (1000 req/hour, 10000 req/day per key)
Agent health monitoring
Auto-import from GitHub trending and HuggingFace
| Method | Endpoint | Description |
|--------|----------|-------------|
| POST | /api/agents/:id/invoke | Invoke an agent |
| GET | /api/agents | List all agents |
| GET | /api/agents/:id | Get agent details |
| GET | /api/agents/:id/health | Check agent health |
| GET | /api/stats | Platform statistics |
Full API documentation: 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 | Required | Description |
| Yes | PostgreSQL connection string |
| No | Stripe API key for payments |
| No | Stripe webhook signing secret |
| No | Google OAuth client ID |
| No | Google OAuth client secret |
| No | SMTP server for emails |
| No | SMTP username |
| No | SMTP password |
Push to GitHub
Create project in Zeabur
Import the repo + add PostgreSQL service
Zeabur auto-injects DATABASE_URL
Frontend: React 18, Tailwind CSS, shadcn/ui, TanStack Query, wouter
Backend: Express 5, Drizzle ORM, Passport
Database: PostgreSQL
Payments: Stripe Connect
Auth: bcrypt, Google OAuth, TOTP 2FA
Deploy: 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
└── DockerfilePull requests welcome. For major changes, open an issue first.
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. Dates show when Glama detected each change.
v1.0.0check_agent_healthget_agentget_platform_statsinvoke_agentlist_agentsEach 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.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
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.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/doggychip/agentforge'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
