# What AI Models Does PrimeAgent Support? Complete Provider Registry Guide

> Discover the extensive AI models PrimeAgent supports, including OpenAI, Anthropic, and Google. Explore our provider registry guide to integrate seamlessly.

- Repository: [Prime Intellect/prime-agent](https://github.com/PrimeIntellect-ai/prime-agent)
- Tags: api-reference
- Published: 2026-08-09

---

**PrimeAgent supports over 20 AI providers—including OpenAI, Anthropic, Google, AWS Bedrock, DeepSeek, and GitHub Copilot—through a provider-agnostic registry system defined in [`packages/ai/src/models.generated.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/ai/src/models.generated.ts) and accessed via runtime helpers in [`packages/ai/src/models.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/ai/src/models.ts).**

PrimeAgent, developed by PrimeIntellect-ai, implements a comprehensive model registry that abstracts provider-specific implementations into a unified interface. This architecture allows the agent to invoke diverse AI models—from Claude and GPT-5 to specialized coding models—while maintaining consistent cost tracking and capability detection across all supported backends.

## The Provider-Agnostic Model Registry

The foundation of PrimeAgent's multi-model support lies in its auto-generated model catalog. At build time, the system generates [`packages/ai/src/models.generated.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/ai/src/models.generated.ts), which enumerates every available AI model with complete metadata including pricing, context windows, and capability flags. The runtime module [`packages/ai/src/models.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/ai/src/models.ts) imports this registry and exposes type-safe accessors for resolving models during agent execution.

This separation between generated data and runtime logic ensures that adding support for new AI models requires only regenerating the catalog, without modifying the core agent codebase.

## Supported AI Providers

The `KnownProvider` type in [`packages/ai/src/types.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/ai/src/types.ts) (lines 19-51) defines the complete enumeration of supported backends. PrimeAgent categorizes these into several families:

**Major Cloud Providers:**
- `amazon-bedrock` – AWS Bedrock models (Claude, Llama, Mistral, MiniMax)
- `anthropic` – Direct Anthropic API access
- `google` / `google-vertex` – Google Generative AI and Vertex AI platforms
- `openai` / `openai-codex` – OpenAI chat completions and Codex models

**Specialized Inference Platforms:**
- `prime-inference` – Prime Agent's proprietary inference gateway
- `deepseek` – DeepSeek model family
- `github-copilot` – GitHub Copilot integration
- `mistral`, `minimax`, `moonshotai` – Specialized model providers

**Third-Party Gateways:**
- `xai`, `groq`, `cerebras`, `openrouter`, `vercel-ai-gateway`, `zai`
- `huggingface`, `fireworks`, `opencode`, `kimi-coding`
- `cloudflare-workers-ai`, `xiaomi*`

The registry supports extensibility; new providers can be added by updating the type definitions and regenerating [`models.generated.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/models.generated.ts).

## Model Metadata and Capabilities

Each model in the registry conforms to the `Model<Api>` interface, containing rich metadata that enables runtime capability detection and cost optimization. Key fields include:

- **`id`** – Unique identifier (e.g., `anthropic.claude-opus-4-7`)
- **`name`** – Human-readable model designation
- **`api`** – Low-level API implementation (`bedrock-converse-stream`, `openai-completions`, etc.)
- **`provider`** – Owning provider from the `KnownProvider` enumeration
- **`baseUrl`** – Custom endpoint URL when applicable
- **`reasoning`** – Boolean flag indicating chain-of-thought and tool usage support
- **`thinkingLevelMap`** – Optional mapping of supported reasoning intensities (`off`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`)
- **`input`** – Accepted input modalities (`text`, `image`)
- **`cost`** – Per-token pricing structure (input, output, cache read/write in USD × 10⁶)
- **`contextWindow`** – Maximum retained context tokens
- **`maxTokens`** – Maximum generation length

The [`models.generated.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/models.generated.ts) file contains complete entries for Bedrock-hosted models (Claude, Llama, Mistral, MiniMax), OpenAI-style models (GPT-5.x series), Google Gemini variants, NVIDIA Nemotron, and numerous specialized coding models.

## Runtime API for Model Access

PrimeAgent exposes three primary helpers in [`packages/ai/src/models.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/ai/src/models.ts) (lines 4-38) for runtime model resolution:

**`getModel`** – Retrieves a specific model by provider and ID with full type safety:

```typescript
export function getModel<TProvider extends KnownProvider, TModelId extends keyof (typeof MODELS)[TProvider]>(
  provider: TProvider,
  modelId: TModelId,
): Model<ModelApi<TProvider, TModelId>>;

```

**`getProviders`** – Returns the complete list of available providers:

```typescript
export function getProviders(): KnownProvider[];

```

**`getModels`** – Lists all models for a specific provider:

```typescript
export function getModels<TProvider extends KnownProvider>(
  provider: TProvider,
): Model<ModelApi<TProvider, keyof (typeof MODELS)[TProvider]>>[];

```

These functions enforce compile-time validation of provider-model combinations while enabling the coding agent to resolve user selections, validate capabilities, and compute usage costs dynamically.

## Working with the Model Registry

The following examples demonstrate common operations against the PrimeAgent model system.

**Listing all available providers:**

```typescript
import { getProviders } from '@/ai/src/models';

const providers = getProviders();
console.log('Supported providers:', providers);

```

**Enumerating models for a specific provider:**

```typescript
import { getModels } from '@/ai/src/models';

const bedrockModels = getModels('amazon-bedrock');
bedrockModels.forEach(m => {
  console.log(`${m.id} – ${m.name} (reasoning=${m.reasoning})`);
});

```

**Inspecting model capabilities:**

```typescript
import { getModel } from '@/ai/src/models';

const model = getModel('amazon-bedrock', 'anthropic.claude-opus-4-7');
console.log('Model name:', model.name);
console.log('Supported thinking levels:', model.thinkingLevelMap);
console.log('Input modalities:', model.input);

```

**Calculating generation costs:**

```typescript
import { calculateCost, getModel } from '@/ai/src/models';
import type { Usage } from '@/ai/src/types';

const model = getModel('openai', 'gpt-5.5');
const usage: Usage = {
  input: 500,
  output: 1000,
  cacheRead: 0,
  cacheWrite: 0,
  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
};

calculateCost(model, usage);
console.log('Estimated cost (USD):', usage.cost.total);

```

## Summary

- PrimeAgent supports over 20 AI providers through a unified registry system defined in [`packages/ai/src/types.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/ai/src/types.ts) and [`packages/ai/src/models.generated.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/ai/src/models.generated.ts).
- The `KnownProvider` type includes major platforms (OpenAI, Anthropic, Google, AWS Bedrock) alongside specialized gateways (Groq, Cerebras, DeepSeek, GitHub Copilot).
- Each model entry contains comprehensive metadata including pricing, context windows, reasoning capabilities, and supported input modalities.
- Runtime access is provided through type-safe helpers (`getModel`, `getProviders`, `getModels`) implemented in [`packages/ai/src/models.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/ai/src/models.ts).
- The build-time generation strategy allows seamless extension of the model catalog without modifying core agent logic.

## Frequently Asked Questions

### Which providers does PrimeAgent support out of the box?

PrimeAgent includes native support for over 20 providers defined in the `KnownProvider` type within [`packages/ai/src/types.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/ai/src/types.ts). This encompasses major cloud AI platforms (OpenAI, Anthropic, Google Vertex AI, AWS Bedrock), specialized inference services (DeepSeek, Mistral, MiniMax, Moonshot AI), and third-party gateways (Groq, Cerebras, OpenRouter, Vercel AI Gateway). The registry also supports GitHub Copilot and Prime Agent's own `prime-inference` gateway.

### How does PrimeAgent handle model capabilities like reasoning and thinking levels?

Each model entry in the generated registry includes a `reasoning` boolean flag and an optional `thinkingLevelMap` property that defines supported reasoning intensities ranging from `off` to `max`. These metadata fields enable the agent to automatically adjust prompting strategies and tool usage based on the selected model's cognitive capabilities, as defined in the `Model<Api>` interface.

### Can I add custom models or providers to PrimeAgent?

Yes. The registry architecture allows extension by adding new entries to the provider definitions in [`packages/ai/src/types.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/ai/src/types.ts) and regenerating [`packages/ai/src/models.generated.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/ai/src/models.generated.ts). This build-time generation approach ensures that custom providers integrate seamlessly with existing runtime helpers like `getModel()` and `calculateCost()`, maintaining type safety across the entire codebase.

### How does PrimeAgent calculate token costs across different providers?

The `calculateCost` function in [`packages/ai/src/models.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/ai/src/models.ts) consumes model-specific pricing data from the registry's `cost` field, which stores per-token rates for input, output, and cache operations (in USD × 10⁶). By passing a `Usage` object containing token counts to `calculateCost()`, the system computes accurate cost estimates regardless of the underlying provider's pricing structure.