Forem: AgentOne

Introducing the AI Model Directory

BestCodes — Mon, 04 May 2026 14:33:33 +0000

Today we're open-sourcing the AI Model Directory, the most comprehensive, automatically updated list of AI models and their metadata available today. It's the data layer that powers model selection in AgentOne, and now it's free for anyone to use, fork, or contribute to.

If you'd rather just look at models, we also built a browser for the directory at models.agent-one.dev where you can search, sort, and compare every model in the directory.

Why Does This Exist?

When building AgentOne, I needed a comprehensive list of AI models and their metadata - costs, context windows, supported features, modalities - so AgentOne could give users easy access to every model an AI provider had to offer.

I was frustrated with the existing options:

Models.dev is not comprehensive (it's opinionated), and it often takes anywhere from a few days to weeks for frontier models to be added across all providers
LiteLLM is more comprehensive for some providers, but the data is fragmented and harder to work with
Portkey Models doesn't list as many models as alternatives do
Other catalogs are often developed with a certain product or service in mind, so they wind up being non-agnostic, not comprehensive, or not always up-to-date

The AI Model Directory aims to be easy to use (like Models.dev), truly comprehensive across every provider it includes, and automatically updated with security in mind.

How Does It Work?

A GitHub Actions workflow runs every 24 hours and re-fetches model metadata from every supported provider. Each provider has its own small adapter that knows how to talk to that provider's API or read its docs, and normalizes the response into a single shared schema covering things like:

Pricing: input, output, reasoning, cache read/write, audio in/out
Limits: context, input, and output token limits
Modalities: text, image, audio, video, file (in and out)
Features: attachments, reasoning, tool calls, structured output, temperature
Metadata: knowledge cutoff, release date, last updated, open weights

Every model gets its own folder under data/providers/<provider>/<model-id>/index.toml, so the directory is just a tree of TOML files. This makes it easy to read, easy to diff, and easy to consume from any language. If a provider's data is wrong or missing something, you can drop a metadata.toml (with data overrides) next to the generated file and the next refresh will merge your overrides on top of the fetched data instead of clobbering them.

To provide an experience similar to models.dev/api.json, a data/all.json file is automatically generated as well, so you can pull the entire directory in one fetch. We also provide a data/all.min.json file for less bandwidth consumption:

https://raw.githubusercontent.com/The-Best-Codes/ai-model-directory/refs/heads/main/data/all.min.json

What's In the Directory?

At launch, the directory tracks models from 35+ providers, including OpenAI, Anthropic, Google, xAI, Mistral, DeepSeek, Cohere, Perplexity, OpenRouter, Vercel, GitHub Copilot, GitHub Models, Hugging Face, Groq, Cerebras, Fireworks, Together, DeepInfra, Baseten, Novita, Alibaba, Inception, Venice, Chutes, Friendli, and many more... and that list keeps growing. If your favorite provider isn't there, open an issue or send a PR; adding a new provider is usually a single small adapter file.

Browse It at models.agent-one.dev

Reading TOML files is great for machines, but not always great for humans. So we built a frontend for the directory at models.agent-one.dev.

It's a fast, sortable, searchable table with a column for everything in the schema. You can search across providers, model IDs, features, and modalities at once, sort by any column, and click straight through to a provider's website. It's the easiest way to answer questions like "which models support reasoning and tool calls under $1 per million input tokens?"

The table loads directly from data/all.min.json in the directory repo, so it's always in sync with the latest run.

Using It in Your Own Project

Consuming the directory is easy. Hit the raw GitHub URL for the bundled file:

curl https://raw.githubusercontent.com/The-Best-Codes/ai-model-directory/main/data/all.json

Or:

curl https://raw.githubusercontent.com/The-Best-Codes/ai-model-directory/main/data/all.min.json

You get back a JSON object keyed by provider, with each provider's models nested inside. This is the easiest path if you just need to populate a model picker or a pricing table. Because everything is plain files, you can fork the repo, add your own provider adapters, drop in metadata.toml for models you've measured yourself, and run the same GitHub Actions workflow on your fork. Your fork stays in sync with upstream while keeping your overrides intact.

Security

Because the directory is updated automatically based on data fetched from third-party providers, the data here is only as trustworthy as the providers it comes from. If you're using this to make billing or routing decisions, treat it as a strong default and not as gospel. We have several measures in place to mitigate the obvious vulnerabilities:

Provider endpoints are hardcoded in source, so providers cannot redirect the updater to arbitrary user-controlled URLs
All fetched data is validated against a strict Zod schema before it's written to disk, which helps prevent malformed or unexpected fields from slipping through
Model IDs are normalized into safe directory names before writing, and entries whose normalized name would be empty are rejected
If multiple model IDs normalize to the same directory name, we resolve that deterministically instead of writing multiple conflicting directories
Terminal output is sanitized before logging, which reduces the risk of ANSI escape sequences or control characters spoofing the updater output
Every network fetch has a 60 second timeout so a slow or hostile provider can't hang the update job forever
IDs and names are length-limited and reject raw control characters, which helps defend against weird escapes, invisible junk in logs, and other malformed provider output
Generated model directories that no longer exist upstream are removed automatically on refresh
Overrides stay local: metadata.toml only applies to that model directory and is merged on top of fetched data
The updater does not execute provider-supplied code, shell commands, or HTML; it only fetches remote content, parses it, validates it, and writes normalized TOML files

That said, this is still provider-supplied metadata. A provider can lie about pricing, capabilities, limits, or release dates, and some providers expose better metadata than others. The goal here is to make the pipeline safe and robust, not to pretend third-party metadata is perfectly trustworthy.

What's Next

This is a beta release, so expect a few rough edges. Some of the things we're working on:

More providers (especially regional and self-hosted offerings)
A proper docs site
Programmatic SDKs for JS/TS, Python, and Go

If you want to help shape any of this, join us on Discord, open an issue, or send a PR.

Try It Out

Browse the data: models.agent-one.dev
Read or fork the source: github.com/The-Best-Codes/ai-model-directory
Use it in your app: AgentOne already does

Happy building!

How to Use GPT 5.5 for Agentic Coding

BestCodes — Sat, 25 Apr 2026 00:41:31 +0000

OpenAI's GPT 5.5 is one of the most capable models available for agentic coding - writing code, using tools, running commands, and iterating on complex tasks autonomously. In this guide, you'll learn how to set up GPT 5.5 in AgentOne and start using it for agentic coding workflows.

What Is Agentic Coding?

Agentic coding is when an AI model doesn't just suggest code, it actively writes, runs, debugs, and iterates on code using tools. Instead of copy-pasting snippets from a chatbot, you give the agent a task and it handles the implementation end to end.

GPT 5.5 excels at this because of its strong tool use capabilities, large context window, and ability to follow multistep instructions reliably.

Prerequisites

AgentOne desktop app installed
An OpenAI API key with access to GPT 5.5

If you don't have an OpenAI API key yet, head to platform.openai.com to create one.

Step 1: Open Provider Settings

Launch AgentOne and open Settings. Navigate to the Provider section. This is where you manage all your AI providers and API keys.

Step 2: Add a Custom OpenAI-Compatible Provider

GPT 5.5 isn't in AgentOne's built-in model list yet, so you'll add it as a custom provider. Click the Add Provider button in the top right, then select OpenAI Compatible from the dropdown.

A dialog will appear with fields to configure the new provider.

Step 3: Configure the Provider

Fill in the following fields:

Name: GPT 5.5 (or whatever you'd like to call it)
Base URL: https://api.openai.com/v1
API Key: Your OpenAI API key

You can leave the Custom Headers section empty, as it's only needed for providers that require extra authentication headers.

Step 4: Add the Model

In the same dialog, scroll down to the Models section. You have two options:

Option a: Auto-Fetch Models

Click the Auto button. AgentOne will call OpenAI's /models endpoint and pull in all available models. Find gpt-5.5 in the list and remove any models you don't need.

Option B: Add Manually

Click the Add button to open the model form. Fill in:

Model ID: gpt-5.5
Display Name: GPT 5.5 (optional, for a cleaner label in the UI)

Make sure both Supports Tools and Supports Images are toggled on… GPT 5.5 supports both!

Click Add Model, then click Add Provider to save everything.

Step 5: Select GPT 5.5 in the Model Selector

Go back to the main chat view. Click the model selector (the model name shown near the input area) and you should see GPT 5.5 listed under your custom provider. Select it.

That's it. You're now using GPT 5.5 for all your conversations in AgentOne.

Step 6: Start Agentic Coding

With GPT 5.5 selected, you can give AgentOne tasks like:

"Create a REST API with Express and PostgreSQL"
"Refactor this component to use React hooks"
"Write tests for the auth module"
"Find and fix the bug in the payment flow"

GPT 5.5 will use AgentOne's tool system to read your files, write code, run terminal commands, and iterate until the task is done.

Tips for Getting the Best Results

Be specific. Instead of "make it better," say "add input validation to the sign-up form and return proper error messages."
Give context. Mention the framework, language, and any constraints. "Use TypeScript, Prisma, and the existing database schema in prisma/schema.prisma."
Let it iterate. Agentic coding works best when you let the model run commands, see errors, and fix them on its own.

Adding Other GPT 5.5 Variants

OpenAI offers several GPT 5.5 model variants. You can add multiple model IDs to the same provider:

Model ID	Best for
`gpt-5.5`	General agentic coding tasks
`gpt-5.5-pro`	More expensive, but smarter

To add more models, go to Settings > Providers, expand your GPT 5.5 provider, and use the Add button in the Models section.

Wrapping Up

Setting up GPT 5.5 in AgentOne takes less than a minute. Once configured, you get a powerful agentic coding environment where GPT 5.5 can read, write, and run your code autonomously.

If you run into issues, make sure your OpenAI API key has access to the gpt-5.5 model and that your base URL is set to https://api.openai.com/v1.

Give it a try! Download AgentOne and start building with GPT 5.5 today. Need help? Join the AgentOne Discord server.