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

> Explore FreeLLMAPI's 13 supported coding agents like Claude Code and Codex CLI. This guide covers auto-configuration and a unified OpenAI-compatible gateway for seamless integration. Get started today.

- Repository: [Tashfeen/freellmapi](https://github.com/tashfeenahmed/freellmapi)
- Tags: tutorial
- Published: 2026-08-29

---

**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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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)](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)](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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/cli/src/index.ts) parses `setup-<agent>` commands and dispatches execution to the appropriate generator function via `getTool`, while [`cli/src/types.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/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

```bash
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)](https://github.com/tashfeenahmed/freellmapi/blob/main/cli/src/tools.ts#L52-L73).

### Configure Codex CLI

```bash
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](https://github.com/tashfeenahmed/freellmapi/blob/main/cli/src/tools.ts#L84-L112).

### Configure OpenCode

```bash
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](https://github.com/tashfeenahmed/freellmapi/blob/main/cli/src/tools.ts#L22-L30).

### Generic OpenAI Client Usage

For clients that do not require file-based configuration:

```bash
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](https://github.com/tashfeenahmed/freellmapi/blob/main/cli/src/tools.ts#L91-L99).

## Key Source Files and Architecture

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

| File | Role |
|------|------|
| [`docs/clients.md`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/docs/clients.md) and implemented in the tool registry at [`cli/src/tools.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/cli/src/tools.ts).

### How does FreeLLMAPI automatically configure coding agents?

The CLI parses `setup-<agent>` commands in [`cli/src/index.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/cli/src/index.ts) and dispatches them to specialized `generate` functions defined in [`cli/src/tools.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/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.