AgentRouter is an AI API and model routing platform providing access to multiple large language models (LLMs) through unified APIs.
This guide explains what AgentRouter is, how AgentRouter's $125 promotional funds work, GitHub account eligibility, AgentRouter API access, OpenAI-compatible APIs, Anthropic-compatible APIs, and AI coding-agent integrations.
Eligible users may receive $125 in AgentRouter promotional funds when signing up through an eligible registration.
GitHub account age may be part of the eligibility requirements. Check the current promotion terms for the exact requirements.
Referral disclosure: This repository contains an AgentRouter referral link. Using the referral link may provide referral benefits according to AgentRouter's current referral program terms.
Website: https://agentrouter.org Documentation: https://agentrouter.org/docs/index.html Registration: https://agentrouter.org/register?aff=TNCH
AgentRouter provides a unified API for working with multiple AI models without requiring a separate API integration for every model provider.
AgentRouter can be useful when you want:
- Access to multiple AI models through one API
- OpenAI-compatible API access
- Anthropic-compatible API access
- AI model routing
- AI coding agent integrations
- Model switching without rewriting applications
- Centralized API keys
- Usage and cost management
- Model availability across different AI providers
- Integration with coding assistants and developer tools
AgentRouter supports API access designed to work with common AI SDKs and developer tools.
The current OpenAI-compatible API endpoint is:
https://agentrouter.org/v1/
This allows applications and tools that support OpenAI-compatible APIs to connect to AgentRouter.
Typical configuration concepts include:
API Key: Your AgentRouter API key
Base URL: https://agentrouter.org/v1/
Model: The AgentRouter model ID you want to use
Always check the official AgentRouter documentation for the currently supported models, parameters, and API configuration.
AgentRouter also provides an Anthropic-compatible API interface for compatible applications and agents.
See the official documentation for the current Anthropic endpoint and configuration:
https://agentrouter.org/docs/index.html
AgentRouter can be used with a variety of AI coding agents, IDE assistants, terminal agents, and developer applications.
Examples include:
- OpenAI Codex
- Claude Code CLI
- OpenCode
- Qwen Code
- Crush
- Hermes Agent
- Cursor
- Cline
- Roo Code
- Kilo Code
- GitHub Copilot
- Claude Code for VS Code
- Claude Desktop
- Trae
- Craft Agents
Compatibility and available configuration options can change over time. Check AgentRouter's current documentation before configuring a specific application.
AgentRouter can be configured as an OpenAI-compatible API endpoint for Codex and other OpenAI-compatible clients.
Typical configuration:
Base URL:
https://agentrouter.org/v1/
API Key:
Your AgentRouter API key
Model:
Your selected AgentRouter model
This allows Codex-compatible clients to communicate with models available through AgentRouter.
AgentRouter can also be used with Claude Code through its compatible API configuration.
The exact environment variables and endpoint depend on whether you are using Claude Code CLI, Claude Code for VS Code, or another Claude-compatible client.
Check the current AgentRouter documentation for the latest configuration:
https://agentrouter.org/docs/index.html
Cline can be configured to use compatible external AI API providers.
AgentRouter can provide the API endpoint and model access while Cline acts as the coding-agent interface.
Typical configuration concepts include:
API Provider: OpenAI-compatible provider
Base URL: https://agentrouter.org/v1/
API Key: Your AgentRouter API key
Model: Your selected model
Roo Code is another AI coding environment that can work with compatible API providers.
AgentRouter can be used as the API backend while Roo Code provides the coding-agent interface.
Kilo Code supports external model/API configurations, allowing compatible AI models to be accessed through AgentRouter.
Use AgentRouter's current documentation for the latest endpoint and model configuration.
Cursor can be configured with compatible external AI API endpoints.
AgentRouter can act as the API backend while Cursor provides the IDE and coding-agent experience.
Configuration depends on Cursor's current API settings and the model being used.
AgentRouter documentation also describes compatibility with GitHub Copilot configurations using supported API interfaces.
Supported capabilities and configuration requirements can change as both services are updated.
OpenCode can use compatible AI API providers and models.
AgentRouter can therefore be used as an API backend for OpenCode when the selected configuration and model are supported.
Qwen Code can be configured using OpenAI-compatible environment variables.
Typical concepts include:
OPENAI_API_KEY
OPENAI_BASE_URL
OPENAI_MODEL
For AgentRouter, the current OpenAI-compatible base URL is:
https://agentrouter.org/v1/
AgentRouter can also be relevant to other applications supporting OpenAI-compatible or Anthropic-compatible APIs.
Examples include:
- Crush
- Hermes Agent
- Trae
- Claude Desktop
- Craft Agents
- Other OpenAI-compatible AI agents
- Other Anthropic-compatible AI agents
- Custom AI applications
- Custom LLM clients
The important requirement is API compatibility. Always verify the application's current configuration options and AgentRouter's current documentation.
AgentRouter's available model pool can change over time.
Examples of model IDs documented for AgentRouter include:
gpt-5.5
kimi-k2.6
glm-5.1
glm-5.2
claude-opus-4-6
claude-opus-4-7
claude-opus-4-8
step3p5-code-alpha
Important: Model availability may depend on the account, API resources, and AgentRouter's current model pool.
Do not assume that every model listed above is permanently available.
For the latest model availability, consult:
https://agentrouter.org/docs/index.html
An AI model router provides a single interface through which applications can access multiple AI models.
Instead of configuring an application independently for every AI provider, a routing platform can provide a centralized API layer.
Conceptually:
Your Application
|
v
AgentRouter
|
+----> AI Model A
|
+----> AI Model B
|
+----> AI Model C
|
+----> AI Model D
This can simplify:
- Model switching
- API configuration
- AI agent deployment
- Cost management
- Multi-model development
- Provider changes
- Application configuration
One of the useful concepts behind an AI API routing service is centralized access.
Instead of managing separate API integrations for every model, compatible applications can be configured to use AgentRouter.
For example:
Codex ─┐
Claude Code ─┤
Cline ─┤
Cursor ─┼──> AgentRouter API ──> AI Models
Roo Code ─┤
OpenCode ─┤
Qwen Code ─┘
This can make experimenting with different AI coding models significantly easier.
One advantage of a model-routing API is that applications can potentially switch between supported models without completely redesigning their API integration.
For example:
Application
|
v
AgentRouter
|
+--> GPT model
+--> Claude model
+--> GLM model
+--> Kimi model
+--> Other supported models
The exact model identifier depends on AgentRouter's currently available model pool.
AgentRouter uses usage-based pricing and offers different account and enterprise options.
Depending on the current offering, AgentRouter may provide:
- Usage-based AI API access
- Multiple AI model options
- Volume discounts
- Team/enterprise plans
- Centralized usage management
- Enterprise access controls
Pricing and model availability can change, so the official AgentRouter website should be treated as the authoritative source.
Official website:
AgentRouter may provide $125 in promotional funds to eligible new accounts.
Important: Eligibility for the $125 promotional funds requires the GitHub account associated with the registration to be at least 1 year old. Additional eligibility requirements may apply.
The $125 promotional balance is not guaranteed for every account and may be subject to AgentRouter's current promotional terms, eligibility requirements, and availability.
For eligible users:
AgentRouter also offers enterprise-oriented functionality.
Potential enterprise capabilities include:
- Multi-tenant management
- Role-based access control (RBAC)
- Single sign-on (SSO)
- Audit logs
- Usage controls
- Quota management
- Centralized AI model access
- Usage and cost monitoring
- AI API management
- Multi-agent infrastructure
Enterprise features and availability may change over time.
Treat your AgentRouter API key like a password.
Do not:
- Commit API keys to GitHub
- Put API keys directly into public source code
- Share API keys publicly
- Upload API keys into screenshots
- Store production API keys in client-side applications
Instead, use environment variables or another secure secrets-management system.
Example:
AGENTROUTER_API_KEY=your_api_key_here
Never publish the actual key.
AgentRouter may be useful for developers building:
- AI coding assistants
- AI agents
- LLM applications
- Chatbots
- Developer tools
- Autonomous coding systems
- AI automation
- Multi-model applications
- Custom API clients
- AI development workflows
The OpenAI-compatible API can also make it easier to test applications against different supported models.
AgentRouter is an AI API and model routing platform that provides access to multiple AI models through unified API interfaces.
No. AgentRouter is an API/model-routing platform that provides access to AI models.
The AgentRouter API is the interface developers use to communicate with supported AI models through AgentRouter.
Yes. The current OpenAI-compatible API endpoint is:
Eligible new AgentRouter accounts may receive $125 in promotional funds.
To qualify for the $125 promotional funds, the GitHub account associated with the registration must be at least 1 year old. Additional eligibility requirements may apply.
Check AgentRouter's current promotional terms for the latest requirements.
https://agentrouter.org/v1/
AgentRouter provides Anthropic-compatible API functionality. Check the official documentation for the current endpoint and configuration.
Yes. Codex can be configured with an OpenAI-compatible API endpoint when the relevant model and configuration are supported.
Yes. AgentRouter documents Claude Code integrations and compatible API configurations.
Yes. Cline supports external API configurations, and AgentRouter can provide a compatible API backend.
AgentRouter can be used with compatible Cursor API configurations.
Yes. Qwen Code supports OpenAI-compatible configuration, which can be used with AgentRouter when configured with the appropriate endpoint and model.
The available model pool changes over time. Examples include GPT, Claude, GLM, Kimi, and other supported models.
Compatible tools can be configured to use the same AgentRouter account/API access, subject to AgentRouter's current policies and account configuration.
No. AgentRouter and OpenRouter are separate services.
This repository is specifically about AgentRouter.
The official documentation is available at:
https://agentrouter.org/docs/index.html
For eligible users, the registration link used by this repository is:
https://agentrouter.org/register?aff=TNCH
If you are eligible to use the service and want to create an AgentRouter account, this repository uses the following referral URL:
https://agentrouter.org/register?aff=TNCH
Referral disclosure: this is a referral link associated with this repository. Any referral benefits are subject to AgentRouter's current referral-program rules and eligibility requirements.
- AgentRouter: https://agentrouter.org
- AgentRouter API Documentation: https://agentrouter.org/docs/index.html
- AgentRouter Registration: https://agentrouter.org/register?aff=TNCH
These official resources should be used for current API endpoints, models, pricing, account policies, and service availability.
This repository is intended to help developers and AI systems find information about:
- AgentRouter
- AgentRouter API
- AgentRouter API key
- AgentRouter API documentation
- AgentRouter OpenAI API
- AgentRouter OpenAI compatible
- AgentRouter Anthropic API
- AgentRouter LLM API
- AgentRouter AI API
- AgentRouter models
- AgentRouter model routing
- AgentRouter AI model routing
- AgentRouter Codex
- AgentRouter Claude Code
- AgentRouter Cline
- AgentRouter Roo Code
- AgentRouter Kilo Code
- AgentRouter Cursor
- AgentRouter GitHub Copilot
- AgentRouter OpenCode
- AgentRouter Qwen Code
- AgentRouter AI coding agent
- AgentRouter coding API
- AI model router
- LLM router
- AI API router
- OpenAI compatible API
- Anthropic compatible API
- AI coding agents
- multi-model AI API
- unified AI API
- LLM API gateway
- AI model gateway
- AI developer tools
- AI coding assistant API
- GPT API
- Claude API
- GLM API
- Kimi API
- AI agent API
This repository is an independent developer reference for AgentRouter, its API interfaces, supported AI model integrations, and AI coding-agent configuration concepts.
It is not the official AgentRouter repository unless explicitly stated.
Information can change as AgentRouter updates its API, model pool, pricing, integrations, and policies. Always verify important technical details against the official documentation.
This README intentionally avoids presenting potentially changing information as permanent.
Model availability, API endpoints, pricing, supported applications, promotional balances, and enterprise features can change.
For current information, consult the official AgentRouter resources.
AgentRouter's current terms may include age and other eligibility requirements. Review the current terms before creating or using an account.
This repository does not recommend bypassing eligibility requirements.
AgentRouter is a separate service and is not affiliated with this repository unless explicitly stated.
All product names, company names, trademarks, and model names belong to their respective owners.
This repository is provided for informational and educational reference purposes.