Complete Guide to FreeLLMAPI Coding Agents: Supported Tools and Auto-Configuration

FreeLLMAPI supports 13 distinct coding agents—including Claude Code, Codex CLI, Cline, Continue, Aider, OpenCode, Goose, Qwen Code, Roo Code, Kilo Code, DeepSeek Harness, MiMo Code, and Cursor—through a unified OpenAI-compatible gateway that automatically generates configuration files via the freellmapi CLI.

FreeLLMAPI functions as a local-first OpenAI-compatible gateway that standardizes access to large language models for software development. Rather than manually configuring API endpoints for each tool, developers use the centralized FreeLLMAPI coding agents registry located in cli/src/tools.ts to automatically provision client-specific settings, authentication keys, and model selections.

Supported FreeLLMAPI Coding Agents

The platform categorizes supported agents into code-generation assistants and general agent frameworks. According to the source code in [cli/src/tools.ts](https://github.com/tashfeenahmed/freellmapi/blob/main/cli/src/tools.ts) and the documentation in [docs/clients.md](https://github.com/tashfeenahmed/freellmapi/blob/main/docs/clients.md), the following agents are fully supported:

AI Coding Assistants

These tools specialize in code generation, refactoring, and repository-level operations:

• Claude Code: Configures ~/.claude/settings.json to use the Anthropic Messages endpoint through the gateway root URL.
• Codex CLI: Generates ~/.codex/config.toml with wire_api = "responses" for OpenAI Responses API compatibility.
• Cline: Creates ~/.cline/data/settings/providers.json for OpenAI-compatible chat endpoints.
• Continue: Writes ~/.continue/config.yaml supporting both OpenAI Chat and legacy Completions APIs.
• Aider: Produces ~/.aider.conf.yml with the OpenAI-compatible base URL.
• OpenCode: Configures ~/.config/opencode/opencode.json using the @ai-sdk/openai-compatible SDK.
• Goose: Sets up ~/.config/goose/custom_providers/freellmapi.json plus ~/.config/goose/config.yaml for OpenAI-compatible chat.
• Qwen Code: Generates ~/.qwen/settings.json and ~/.qwen/.env, supporting both OpenAI-compatible and native Gemini endpoints.
• Roo Code: Creates ~/.roo/freellmapi.json for OpenAI-compatible chat.
• Kilo Code: Writes ~/.config/kilo/kilo.jsonc with OpenAI-compatible configuration.
• MiMo Code: Configures $XDG_CONFIG_HOME/mimocode/config.json via the OpenAI-compatible SDK.
• Cursor: Requires a public tunnel and overrides the OpenAI Base URL (no local config file generation).

Agent Frameworks

• DeepSeek Harness (dsh): Generates $DSH_HOME/settings.yaml and $DSH_HOME/.env with api: openai-completions configuration.
• Generic OpenAI Client: Requires only environment variables (OPENAI_BASE_URL and OPENAI_API_KEY) with no file generation.

How FreeLLMAPI Auto-Configures Coding Agents

The automatic configuration system relies on a tool registry architecture defined in cli/src/tools.ts. Each supported agent implements a generate function that creates the necessary client-specific configuration files and directory structures.

The configuration flow follows three distinct phases:

1. Discovery: FreeLLMAPI publishes a live model catalogue at http://localhost:3001/v1/models.
2. Selection: The setup script selects a model (defaulting to auto or a specific identifier) from the catalogue.
3. Configuration: The CLI writes minimal configuration files embedding the gateway base URL (v1Url) and unified API key (FREELLMAPI_API_KEY).

The CLI entry point in cli/src/index.ts parses setup-<agent> commands and dispatches execution to the appropriate generator function via getTool, while cli/src/types.ts defines the TypeScript interfaces—including CatalogModel, GenerateContext, and ToolDefinition—that enforce type safety across all agent configurations.

Setting Up Specific Coding Agents

FreeLLMAPI provides dedicated CLI commands for each supported agent. Below are practical examples demonstrating the setup process and generated file locations.

Configure Claude Code

export FREELLMAPI_API_KEY=<unified-key>
npx freellmapi setup-claude --url http://localhost:3001

This command creates ~/.claude/settings.json containing the gateway URL and authentication credentials, as implemented in the generate function at [lines 52-73 of cli/src/tools.ts](https://github.com/tashfeenahmed/freellmapi/blob/main/cli/src/tools.ts#L52-L73).

Configure Codex CLI

export FREELLMAPI_API_KEY=<unified-key>
npx freellmapi setup-codex --url http://localhost:3001

The operation generates ~/.codex/config.toml pointing to the /v1 endpoint with the responses wire API type and marks the provider as FreeLLMAPI, defined at lines 84-112.

Configure OpenCode

export FREELLMAPI_API_KEY=<unified-key>
npx freellmapi setup-opencode --url http://localhost:3001

This produces ~/.config/opencode/opencode.json that the OpenAI-compatible SDK consumes, referencing the gateway configuration at lines 22-30.

Generic OpenAI Client Usage

For clients that do not require file-based configuration:

export OPENAI_BASE_URL=http://localhost:3001/v1
export OPENAI_API_KEY=$FREELLMAPI_API_KEY
curl $OPENAI_BASE_URL/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"auto","messages":[{"role":"user","content":"Hello"}]}'

This approach relies solely on environment variables without writing configuration files, as documented in the tool registry at lines 91-99.

Key Source Files and Architecture

Understanding the codebase structure helps developers extend support for additional coding agents:

File	Role
docs/clients.md	Human-readable overview documenting all supported clients and agents, including the comprehensive coding agents table referenced in this guide.
cli/src/tools.ts	Central tool registry containing generate functions for each agent that produce per-client configuration files and directory structures.
cli/src/index.ts	CLI entry point that parses setup-<agent> subcommands and dispatches execution to the appropriate generator via the getTool function.
cli/src/types.ts	Type definitions for CatalogModel, GenerateContext, and ToolDefinition that standardize the configuration generation interface.

Summary

• FreeLLMAPI supports 13+ coding agents ranging from Claude Code and Codex CLI to specialized frameworks like DeepSeek Harness and OpenCode.
• Automatic configuration occurs through the freellmapi CLI, which uses the tool registry in cli/src/tools.ts to generate client-specific files.
• Three-phase setup involves model discovery at localhost:3001/v1/models, model selection (defaulting to auto), and file generation with embedded FREELLMAPI_API_KEY.
• Configuration paths vary by agent, with files written to standard locations like ~/.claude/settings.json, ~/.codex/config.toml, and ~/.continue/config.yaml.
• Generic OpenAI clients require only environment variables (OPENAI_BASE_URL and OPENAI_API_KEY) without file generation.

Frequently Asked Questions

Which coding agents are supported by FreeLLMAPI?

FreeLLMAPI supports Claude Code, Codex CLI, Cline, Continue, Aider, OpenCode, Goose, Qwen Code, Roo Code, Kilo Code, MiMo Code, Cursor, DeepSeek Harness (dsh), and generic OpenAI-compatible clients. Each agent is documented in docs/clients.md and implemented in the tool registry at cli/src/tools.ts.

How does FreeLLMAPI automatically configure coding agents?

The CLI parses setup-<agent> commands in cli/src/index.ts and dispatches them to specialized generate functions defined in cli/src/tools.ts. These functions write the minimal required configuration files (JSON, TOML, or YAML) containing the gateway URL http://localhost:3001/v1 and the unified FREELLMAPI_API_KEY.

What configuration files does FreeLLMAPI generate for Claude Code and Codex CLI?

For Claude Code, the CLI creates ~/.claude/settings.json configured for the Anthropic Messages endpoint. For Codex CLI, it generates ~/.codex/config.toml with wire_api = "responses" to utilize the OpenAI Responses API format. Both files embed the local gateway URL and authentication token.

Can I use FreeLLMAPI with generic OpenAI-compatible clients?

Yes. FreeLLMAPI maintains full OpenAI API compatibility, allowing any client that accepts standard OPENAI_BASE_URL and OPENAI_API_KEY environment variables to connect without generating configuration files. Simply point the client to http://localhost:3001/v1 and provide the FreeLLMAPI key for immediate access to the local model catalogue.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}