DEV Community: Tokely — AI API Platform

Agent Skills Moves to the Agentic AI Foundation: What Developers Need to Know

Tokely — AI API Platform — Sat, 24 Oct 2026 05:02:22 +0000

Short answer: Anthropic donated the Agent Skills standard to the Agentic AI Foundation on October 22, 2026. This transfer places the skill specification under neutral Linux Foundation governance alongside the Model Context Protocol. Developers can build skills using simple local directories, Markdown instructions, and executable scripts, then run them across dozens of supported agent clients and model backends without encountering platform lock-in.

What did Anthropic donate on October 22?

On October 22, 2026, Anthropic transferred the Agent Skills standard and all related assets to the Agentic AI Foundation. The donation includes the core specification, the Agent Skills name and logo, the official GitHub organization, and the agentskills.io domain. Anthropic stated that it is committed to keeping Agent Skills open, community-driven, and vendor-neutral.

The Agentic AI Foundation operates as a project under the Linux Foundation to host vendor-neutral agent standards. Anthropic, Block, and OpenAI co-founded the foundation in 2025 to create a shared home for open agent infrastructure. The foundation already hosts the Model Context Protocol, which Anthropic donated in an earlier governance transfer.

Anthropic first launched Agent Skills inside its Claude products in October 2025. Two months later, in December 2025, Anthropic published the underlying format as an open standard for the developer community. Donating the assets to the Agentic AI Foundation completes the transition from a single-vendor feature to a neutral industry specification.

Who maintains Agent Skills now?

Two Lead Maintainers, David Soria Parra and Mahesh Murag, now guide the Agent Skills project. Individual software engineers from Anthropic, Google, OpenAI, and other technology companies maintain the specification on their own behalf rather than through corporate representation.

Development teams do not need to join the Agentic AI Foundation to use the standard or contribute code to the repository.

Anyone who wants to suggest changes to the specification can send feedback through the project's Discord server.

How widely is the standard used?

More than 70 agent platforms have integrated the Agent Skills specification across their production tools. That adoption footprint includes major coding agents and developer environments such as ChatGPT, Cursor, GitHub Copilot, and VS Code.

According to Anthropic, developers have published 1 million skills and end users have installed nearly 280 million skills across those integrated platforms. These are Anthropic's own figures and are not independently audited.

For skill authors, that means one package format across competing platforms. Developers who author a skill can deploy that package directly to multiple editors and command-line agents without rewriting instructions for each client.

What is inside a skill?

A skill is a directory containing at minimum a SKILL.md file with YAML frontmatter followed by standard Markdown instructions. The directory can also house optional subdirectories by convention, including scripts for executable code, references for documentation loaded on demand, and assets for templates, images, or data files.

api-cost-check/
├── SKILL.md
├── scripts/
│   └── estimate.py
└── references/
    └── prices.md

File references inside SKILL.md should be relative paths from the skill root, kept one level deep. The specification advises against long chains of nested references.

The YAML frontmatter defines two required fields: name and description. The name field takes a string between 1 and 64 characters containing only lowercase letters, digits, and single hyphens. It must match the parent directory name exactly, with no leading hyphens, trailing hyphens, or double hyphens.

The description field accepts 1 to 1,024 characters explaining what the skill accomplishes and when the agent should select it. Authors should write clear descriptions with relevant keywords, because the agent runtime inspects this text to decide which skill fits a given user prompt.

Frontmatter also supports four optional fields. The license field names the distribution license, while compatibility accepts up to 500 characters outlining environment requirements. Authors can provide arbitrary string key-value pairs through the metadata map, or specify an experimental allowed-tools list containing space-separated pre-approved tools.

---
name: api-cost-check
description: "Estimates the API cost of a prompt or batch job before it runs. Use when the user asks what a request, batch or agent run will cost on a given model."
license: Apache-2.0
metadata:
  author: example-org
  version: "1.0"
---

# API cost check

1. Count input tokens and estimate output tokens.
2. Read per-1M-token prices from references/prices.md.
3. Run scripts/estimate.py and report the cost per request and per 1,000 requests.

Developers can verify their directory structure and schema formatting before distributing a package. Running skills-ref validate ./my-skill through the skills-ref reference library checks that the frontmatter is valid and follows the naming rules.

How does progressive disclosure keep context small?

Roughly 100 tokens of metadata per skill enter the context window when an agent session initializes. The runtime loads only the name and description fields at startup, allowing an agent to index dozens of capabilities without consuming substantial context space.

The agent defers reading the rest of the package until the user prompt triggers that specific skill. The full body of SKILL.md loads into the active prompt only upon activation, and the specification recommends keeping that body under 5,000 tokens and under 500 lines of text.

Files located inside the scripts, references, and assets subdirectories remain unloaded until the activated instructions specifically call for them. This phased approach prevents large documentation files and scripts from bloating context during unrelated prompts.

Fifty installed skills add about 5,000 tokens of metadata at session start. At an input price of $2 per 1M tokens before prompt caching, loading metadata for all 50 skills costs roughly $0.01 per session.

How are skills different from MCP?

The Model Context Protocol connects an agent to external tools and live data stores through client-server connections. In contrast, an Agent Skill packages procedural instructions, executable scripts, and static reference files that an agent runtime reads directly from disk.

MCP relies on active server processes that expose tool definitions, resources, and prompt templates over standard communication protocols. A skill functions as a static file bundle that informs the model how to complete a specific task using tools already available on the host.

Both standards now operate under the Agentic AI Foundation as complementary building blocks. A skill can direct an agent on when and how to call an MCP server, while the MCP server handles the protocol communication with remote systems.

What is on the roadmap, and why does security matter?

The proposed starting roadmap for Agent Skills focuses on three areas: versioned releases, a formal specification proposal process, and security guidance for authors and users. A structured release cycle will help tool builders maintain compatibility as the format matures under foundation governance.

Security guidance represents an immediate priority because a skill can include arbitrary code in its scripts directory. When a skill's instructions tell the agent to run those scripts, they run with whatever access the agent has on that machine.

Installing a skill therefore means trusting the author who packaged it. Malicious or poorly tested scripts can modify local files, execute dangerous shell commands, or expose sensitive project data. Developers should always review the contents of the scripts directory before installing third-party skills into their environments.

How do you use skills with any model through one API key?

Claude Code reads personal skills from ~/.claude/skills//SKILL.md and project-level skills from .claude/skills//SKILL.md inside the root of a repository.

Skills are plain text files evaluated by the agent client rather than the upstream model provider. Because the client parses the frontmatter and passes the instructions to the model, the same skill files work whichever model the client calls, although results still depend on the model.

Developers can run Claude Code through the Tokely API gateway by setting two environment variables. The skill directories stay exactly as they are.

skills-ref validate ./api-cost-check
ANTHROPIC_BASE_URL=https://api.tokely.me ANTHROPIC_AUTH_TOKEN='<YOUR_TOKELY_API_KEY>' claude

A single Tokely API key and unified balance grants access to Claude, GPT, Gemini, and Kimi models, including Kimi K3.1 Pro. The gateway exposes an Anthropic-compatible endpoint for Claude Code and an OpenAI-compatible endpoint for other agent clients, so a team can test the same skill on several models from one account. You can view all supported options on the Tokely models page or read our guide on using Claude Code with a cheaper API.

Sources

Read the announcement details at Anthropic's announcement and explore technical definitions in the Agent Skills specification. Further context appears in Simon Willison's note and our setup tutorial for Claude Code with a cheaper API.

Originally published at tokely.me.

Kimi K3.1 Pro API Pricing: Half of Claude Opus 5.5, Same as Sonnet 5.5

Tokely — AI API Platform — Sat, 24 Oct 2026 04:49:31 +0000

Short answer: Moonshot AI released Kimi K3.1 Pro at $2 per 1M input tokens and $10 per 1M output tokens. That matches Claude Sonnet 5.5 and cuts Claude Opus 5.5 pricing in half. For long prompts without tiered pricing penalties, Kimi K3.1 Pro provides 1,048,576 tokens of context at a flat rate, alongside a 2 to 3 times faster Highspeed tier at double the price.

What did Moonshot release on October 23?

Moonshot AI released Kimi K3.1 Pro on October 23, 2026, as the first model of its K3.1 series. It is a post-trained successor to Kimi K3, which Moonshot released on July 16, 2026, as a 2.8-trillion-parameter open-weight model. Moonshot announced that the full model weights for K3.1 Pro will be released by November 4, 2026.

The release includes two API model IDs: kimi-k3.1-pro and kimi-k3.1-pro-highspeed. Moonshot removed cyber-attack material from training before the open release. On Moonshot's own benchmark, Kimi K3.1 Pro scored 65.7% on Terminal-Bench 4.0, compared to 66.4% for Claude Opus 5.5 and 58.2% for GPT-6 Astra. These benchmark numbers are Moonshot's own and not independently verified, and price is not capability, so test on your own prompts.

How much does Kimi K3.1 Pro cost?

Kimi K3.1 Pro costs $2 per 1M input tokens on cache misses, $0.20 per 1M cached input tokens on cache hits, and $10 per 1M output tokens. Its predecessor, Kimi K3, lists at $3 per 1M input tokens, $0.30 per 1M cached input tokens, and $15 per 1M output tokens, making K3.1 Pro one third cheaper than the model it replaces.

The faster variant, Kimi K3.1 Pro Highspeed, lists at $4 per 1M input tokens, $0.20 per 1M cached input tokens, and $20 per 1M output tokens. Cache writes for both models are billed separately by time to live for either 5 minutes or 1 hour. The Vercel AI Gateway lists the cache write fee at $2 per 1M tokens for K3.1 Pro and $4 per 1M tokens for Highspeed.

Moonshot uses flat pay-as-you-go pricing across the entire 1,048,576-token context window. There are no price tiers or rate increases as context lengths scale up toward the one-million-token limit. Direct access on Moonshot's platform requires a top-up of at least $1, and top-up totals determine your rate-limit tier.

How does it compare with Claude Opus 5.5, Sonnet 5.5, GPT-6.1 Sol and Gemini 4 Argon?

Claude Opus 5.5 lists at $4 per 1M input tokens and $20 per 1M output tokens, exactly double the standard rates of Kimi K3.1 Pro. Claude Sonnet 5.5 matches Kimi K3.1 Pro at $2 per 1M input tokens and $10 per 1M output tokens. Anthropic bills the full 1M-token context window at standard rates for both models, with cache hits at $0.20 for Opus 5.5 and $0.10 for Sonnet 5.5, and cache writes at $5 or $8 for Opus 5.5 and $2.50 or $4 for Sonnet 5.5.

GPT-6.1 Sol lists at $2 per 1M input tokens, $0.10 per 1M cached tokens, and $10 per 1M output tokens for requests up to 272K input tokens. Above 272K input tokens, GPT-6.1 Sol shifts to $4 per 1M input tokens, $0.20 per 1M cached tokens, and $15 per 1M output tokens. Gemini 4 Argon lists at $2 per 1M input tokens, $10 per 1M output tokens, and $0.10 per 1M cached tokens until November 30, 2026, after which it lists at $4 per 1M input tokens, $20 per 1M output tokens, and $0.20 per 1M cached tokens starting December 1, 2026.

Workload A shows the cost of 1M input tokens and 250K output tokens at list prices. On this workload, Kimi K3.1 Pro, Claude Sonnet 5.5, GPT-6.1 Sol, and Gemini 4 Argon (until November 30) all total $4.50. Kimi K3 totals $6.75, while Claude Opus 5.5 and Kimi K3.1 Pro Highspeed both cost $9.00.

Cost of 1M input plus 250K output tokens at official standard list prices, checked October 24, 2026. Price is not capability: test on your own prompts.

Which model is cheapest for long prompts?

Workload B measures a single long-context request with 500K input tokens and 20K output tokens. For this request, Kimi K3.1 Pro, Claude Sonnet 5.5, and Gemini 4 Argon (until November 30) each cost $1.20. In contrast, GPT-6.1 Sol costs $2.30 because its higher rate tier applies above 272K tokens, while Claude Opus 5.5 and Kimi K3.1 Pro Highspeed each cost $2.40.

Cost of one request with 500K input plus 20K output tokens. Kimi K3.1 Pro, Claude and Gemini 4 Argon keep one rate across the window; GPT-6.1 Sol bills requests above 272K input tokens at its long-context rate.

Caching economics introduce a specific divergence for repetitive workloads. Cached input on K3.1 Pro costs $0.20 per 1M tokens, which is 10% of its base input price. Claude Sonnet 5.5 and GPT-6.1 Sol charge $0.10 per 1M cached tokens, cutting cache hit costs in half relative to Moonshot.

That difference changes the ranking for agent loops that reuse long prefixes. If a team runs deep multi-turn sessions where the same system instructions or documents are cached again and again, Sonnet 5.5 and GPT-6.1 Sol charge less per cached token than Kimi K3.1 Pro, even though all three share the same $2 base input price.

When is Highspeed worth twice the price?

Kimi K3.1 Pro Highspeed is the same model served at 2 to 3 times the generation speed for $4 per 1M input tokens and $20 per 1M output tokens. That doubling in token pricing directly matches the price tag of Claude Opus 5.5. On a 1M input and 250K output workload, Highspeed reaches $9.00 compared to $4.50 on the standard tier.

This pricing premium pays off specifically when latency dictates system success. Interactive developer tools, synchronous code completion, and customer-facing interfaces benefit from cutting generation times by half or more. Moonshot keeps the cache hit price identical across both tiers at $0.20 per 1M tokens, but cache writes cost $4 per 1M tokens on Highspeed compared to $2 on K3.1 Pro.

For asynchronous workflows like offline evaluation, data extraction, or night-time batch processing, the standard Kimi K3.1 Pro model provides identical quality at half the price. Engineering teams should measure whether user drop-off or task timeouts justify paying double for token throughput before setting Highspeed as the default endpoint.

What do you need to change in your code?

Moonshot's K3.1 Pro quickstart defines several fixed parameters that must be omitted from API requests. The API locks temperature to 1.0, top_p to 0.95, n to 1, presence_penalty to 0, and frequency_penalty to 0. Moonshot asks callers to leave them out of every request.

Thinking is always turned on in K3.1 Pro and cannot be disabled. The reasoning_effort parameter accepts low, high, and max, with max set as the default. Moonshot suggests setting reasoning_effort to low to cut reasoning time.

Handling multi-turn conversations and tool calling requires strict message preservation. In multi-turn and tool-call flows, applications must send the complete assistant message back unchanged in subsequent turns.

Output token caps are flexible across the full million-token window. The max_completion_tokens parameter defaults to 131,072 and can be configured up to 1,048,576. For multimodal requests, images must be submitted as base64 data URLs or uploaded file IDs, as public image URLs are not accepted. Moonshot also notes that its built-in web search is being updated and is not recommended for production workloads for now.

What happens to Kimi K2 models?

Moonshot is phasing out its previous generation of models according to a published timeline. From October 31, 2026, Kimi K2 series models are no longer available to newly registered users on Moonshot's platform. Existing users are not affected by that change.

Moonshot plans to retire all K2 series models entirely by the end of December 2026. Moonshot recommends migrating K2 traffic to Kimi K3.1 Pro. Teams already on Kimi K3 also save a third by moving: $2 per 1M input tokens and $10 per 1M output tokens instead of $3 and $15.

How do you use Kimi K3.1 Pro with one API key?

Tokely lists Kimi K3.1 Pro at Moonshot's list price of $2 per 1M input tokens, $10 per 1M output tokens, and $0.20 per 1M cached tokens. Kimi K3.1 Pro Highspeed is also available at list price for $4 per 1M input tokens, $20 per 1M output tokens, and $0.20 per 1M cached tokens. The gateway provides access through an OpenAI-compatible interface, allowing developers to switch models by updating the model identifier.

A single Tokely account, API key, and credit balance connects to Kimi K3.1 Pro alongside Western flagship models. On Tokely, Claude Opus 5.5 lists at $3 per 1M input and $15 per 1M output tokens, Claude Sonnet 5.5 lists at $1.50 per 1M input and $7.50 per 1M output tokens, GPT-6.1 Sol lists at $0.80 per 1M input and $4 per 1M output tokens, and Gemini 4 Argon lists at $1.40 per 1M input and $7 per 1M output tokens. Tokely prices can change, and developers should check the Tokely models page for current rates.

Testing model variations side by side requires no custom client code. The Tokely Playground allows teams to run the same prompt against Kimi K3.1 Pro and competing flagship models simultaneously to evaluate speed, reasoning depth, and formatting. You can call Kimi K3.1 Pro on Tokely with the standard OpenAI Python SDK using the following snippet:

from openai import OpenAI

client = OpenAI(base_url="https://api.tokely.me/v1", api_key="YOUR_TOKELY_API_KEY")
reply = client.chat.completions.create(
    model="kimi-k3.1-pro",
    messages=[{"role": "user", "content": "Review this function for race conditions."}],
    max_tokens=4096,
)
print(reply.choices[0].message.content)

Sources

Prices, parameters and migration dates come from the developers' documentation, checked on October 24, 2026; the Highspeed cache write price comes from the Vercel AI Gateway model list. Review implementation details in the Kimi K3.1 Pro quickstart and examine current rates on the Kimi API pricing page. Compare these figures with Western flagship documentation via Claude pricing, OpenAI API pricing, and Gemini API pricing. For background on training data filtering and the open release schedule, read The Next Web on the release. For extended context cost evaluations, consult our earlier comparison Gemini 4 Argon Pricing vs Claude Sonnet 5.5 and GPT-6.1 Sol.

Originally published at tokely.me.

How to Review AI-Written Code: Lessons From the Claude Code Team and Hacker News

Tokely — AI API Platform — Fri, 23 Oct 2026 09:29:11 +0000

Short answer: Reviewing AI-written code requires moving design decisions upstream and automating verification before a human opens the pull request. Treat the agent as an implementer working against an explicit design spec. Run tests, linters, and a fresh-context subagent review locally, gate pull requests by change risk rather than code author, and route sensitive paths to human reviewers.

Why is AI-written code hard to review?

On October 19, 2026, Hacker News user rzk posted "Ask HN: How to deal with shipping AI-written code you don't understand?" on Hacker News. By October 23, 2026, the thread had 614 points and 748 comments. The post quoted a LinkedIn update from a Meta engineer detailing the core problem: "I'm writing code these days and it all feels like a black box."

The same post explained why line-by-line review stops scaling when agents write most of a change: "if we're going to spend our time checking each line of code, it's going to take forever."

The practical answers in the thread fall into two groups: control the design before the agent writes code, and verify behavior after it does. The Claude Code team's published process does both, and adds rules for when a human must approve.

What do engineers on Hacker News actually do?

In the largest subthread of 183 replies, bitwizeshift argued that control must happen before the model writes any code. The commenter wrote: "I don't let the LLM design the code at all, I let it implement a design I have created." They added: "I may not know how each unit is implemented, but I know each unit's responsibilities and how they interact with one another."

Other engineers in the thread shared this focus on separating system architecture from code implementation. Commenter jedberg summarized the dynamic plainly: "Your job is to design, the AI builds like the junior engineers. Then you review their work." Clear interfaces give the human reviewer a strict boundary against which to evaluate generated logic.

Verification strategies focused heavily on rigorous execution rather than passive reading. Commenter ChrisMarshallNY stated: "Testing. Lots and lots of testing." The same engineer observed: "I don't find coding errors, but I do find implementation errors."

Relying purely on automated tests brings its own specific trap. As commenter edwin0 pointed out: "The part that makes me uneasy is when the AI writes both the code and the tests. They might agree with each other and still miss the same thing."

Accountability remains a requirement for production systems. Commenter plastic041 emphasized: "You must read the code before shipping it to production." The commenter continued: "At least one person in your company should be able to explain the code!"

Engineers also adjust their oversight depending on the system layer. Commenter bob1029 noted that UI code is "basically entirely vibe coded", while "For things like the SQL schema I am still doing things entirely by hand."

How does the Claude Code team review its own code?

Claude writes about 90 percent of Claude Code's own code. On October 15, 2026, Addy Osmani, Morgan Westlee Lunt and Qing Wang published "How the Claude Code team does code review", outlining their seven-layer pipeline.

The first layer verifies the work before anyone else looks at it. Claude runs tests, the build, and the linter and shows the output. Then "a second agent reviews the diff in a fresh context".

The second layer runs an automated AI review on every pull request against the whole repository and the PR's stated intent. Findings are checked by other agents and tagged Important, Nit, or Pre-existing. This directly connects to the advice from bitwizeshift and jedberg, as the explicit intent serves as the review target.

The third layer is a dedicated security review that holds blocking power. The team established a strict merge condition: "A PR can't merge while any finding from the bug review or the security review is still open."

The fourth layer enforces blocking automated checks across the codebase. These are lint, type checks, tests on every platform, and a build.

The fifth layer applies human approval scaled strictly by risk. The sixth layer routes code into a merge queue with feature flags and gradual rollout, exposing new behavior to Anthropic employees first.

The seventh layer provides fast detection and fast rollback. It relies on feature flags that "turn off without a deploy" and a weekly on-call rotation.

To keep the automated reviewer accurate, the team converts past incidents into an eval set. They collected historical pull requests that caused incidents or reverts and run the reviewer against that test suite daily. Every update to the reviewer's prompts, tools, or model is scored against this incident library.

Anthropic made Code Review for Claude Code generally available on October 15, 2026 for Claude Team and Enterprise organizations. Admins pick Quick, Standard (the default), or Deep per repository. Most reviews now take 6 to 10 minutes, down from about 20 minutes during the research preview.

Which changes still need a human?

The Claude Code team relies on three explicit rules to govern review responsibilities. First, "The change sets the tier, not the author." Second, "An agent's approval never counts as a person's." Third, "An approval covers one specific commit."

Low-risk changes require zero human approval once automated review and security checks are green. This tier covers documentation, copy updates, internal-only features, and additive changes isolated behind a feature flag. This matches the split bob1029 described, where interface code gets lighter review than the database schema.

Medium-risk changes require approval from one person. This category includes ordinary product changes and sensitive areas such as caching logic, the auto-updater, or system prompts.

High-risk changes require approval from two people. This tier is reserved for the highest-risk code alongside a small set of sensitive repository paths. This keeps human attention on the changes where a missed bug costs the most.

Did the process work?

The Claude Code team measured the impact of this review system on their internal pull requests. The share of pull requests passing after just one review and fix round increased from 65% to 78%. Pull requests requiring five or more rounds dropped from 8.9% to 1.5%.

Review iteration cycles shortened across the engineering team. The mean number of review rounds required to pass dropped from 2.08 to 1.32.

Throughput expanded alongside code stability between June and September. During that period, total merged pull requests more than doubled while the share of pull requests that had to be reverted fell by more than 40 percent. These figures represent the team's own reported numbers.

A review checklist you can adopt this week

List all checks an agent can execute inside a short CLAUDE.md file. Add hooks that run formatters and linters automatically.

Run /code-review and /security-review commands locally before opening a pull request, or trigger a fresh-context subagent review. The first human reviewer then starts from a diff that has already had one review.

Maintain a REVIEW.md document in your repository and migrate repeated review feedback directly into its rules. Update your pull request template to require sections for "Testing", "Risk", and "How to revert".

Cap the number of review rounds. After the first few rounds, restrict automated re-review so it checks only the newly modified diff rather than re-evaluating the full branch.

Configure CODEOWNERS and branch protection rules so that auth, billing, CI workflows, release workflows, and installers always require a human approver.

Track human engineering time spent on reviews while monitoring revert and production incident rates as your primary guardrail. If revert rates rise, tighten the risk tiers or expand the automated eval suite.

How do you run these reviews through one API key?

Claude Code can run directly with a Tokely API key through Tokely's Anthropic-compatible /v1/messages endpoint. Set ANTHROPIC_BASE_URL to https://api.tokely.me and ANTHROPIC_AUTH_TOKEN to your key, as in this single-line command from the Tokely guide:

ANTHROPIC_BASE_URL=https://api.tokely.me ANTHROPIC_AUTH_TOKEN='<YOUR_TOKELY_API_KEY>' ANTHROPIC_DEFAULT_SONNET_MODEL=claude-sonnet-5 ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-5-5 ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-5-5 claude

Local /code-review and /security-review runs are billed per token from your existing Tokely balance.

The same Tokely API key also accesses OpenAI and Google models, such as GPT-6.1 Sol and Gemini 4 Argon, through the OpenAI-compatible Chat Completions endpoint. That makes it possible to send an agent's diff to a model from a different developer for a second review.

The switch is a change of the model ID. It is one option for edwin0's concern about code and tests sharing the same blind spot, not a proven fix. Tokely is an API gateway and does not run Anthropic's hosted Code Review GitHub App. For implementation details, consult the guide on Claude Code with Tokely and the Tokely Claude Code guide.

Sources

The community perspectives in this guide come from the Ask HN thread posted on October 19, 2026. The review framework and reported metrics come from How the Claude Code team does code review and the product announcement Code Review is now generally available, both published on October 15, 2026.

Originally published at tokely.me.

Gemini 4 Argon Pricing vs Claude Sonnet 5.5 and GPT-6.1 Sol: Same Price Until December 1

Tokely — AI API Platform — Fri, 23 Oct 2026 09:29:10 +0000

Short answer: Gemini 4 Argon, Claude Sonnet 5.5, and GPT-6.1 Sol all list at $2 per 1M input tokens and $10 per 1M output tokens as of October 23, 2026. The tie ends on December 1, 2026, when Google doubles Argon to $4 input and $20 output. Even before then, prompts above 272K tokens cost more on GPT-6.1 Sol.

What changed on October 13?

Google released Gemini 4 Argon (gemini-4-argon) to general availability on the Gemini API on October 13, 2026. Google first showed Argon on September 30, 2026 to a limited group of cyber defenders. The October 13 update opened it to any developer with a paid account.

The release description from Google labels Argon as "our most capable model built for complex coding, agentic, math, and science tasks". Argon is not available on the Free tier, so access requires paid billing on the Gemini API.

Price is not capability, so test each model on your own prompts before you choose one. The current Argon rate applies through November 30, 2026.

How do the list prices compare?

Through November 30, 2026, all three models list standard requests at $2 per 1M input tokens and $10 per 1M output tokens. Cached inputs on all three models cost $0.10 per 1M tokens. Batch workloads on all three models run at $1 per 1M input tokens and $5 per 1M output tokens (up to 272K input tokens on GPT-6.1 Sol).

For a workload of 1M input tokens and 250K output tokens, the total cost comes to $4.50 on Claude Sonnet 5.5, $4.50 on GPT-6.1 Sol, and $4.50 on Gemini 4 Argon. Argon's output price includes thinking tokens, so reasoning counts toward the output bill.

Cost of 1M input plus 250K output tokens at official standard list prices, checked October 23, 2026. Price is not capability: test on your own prompts.

The three models share identical base pricing for standard contexts, but their token limits differ. Argon offers a single 1,048,576-token context window shared by input, thinking, and output tokens. Claude Sonnet 5.5 provides a 1M token context with a 128K max output limit, while GPT-6.1 Sol offers a 1,050,000 context window with a 128K max output limit.

What happens on December 1?

On December 1, 2026, Google raises Gemini 4 Argon standard list rates to $4 per 1M input tokens and $20 per 1M output tokens. Cached inputs increase to $0.20 per 1M tokens, and Batch API pricing rises to $2 per 1M input tokens and $10 per 1M output tokens.

This adjustment doubles production costs for Argon workloads overnight. For the same workload of 1M input tokens and 250K output tokens, the list price on Argon jumps from $4.50 to $9.00. Claude Sonnet 5.5 and GPT-6.1 Sol remain at $4.50 for the same token volume.

Run your evaluation tests before December 1, while Argon still costs $2 input and $10 output. Teams that plan to rely on Argon should recheck cost forecasts for December and 2027 at the doubled list price.

Which model is cheapest for long prompts?

Prompt size breaks the pricing tie between these three providers today. GPT-6.1 Sol applies a split pricing tier based on context length. Requests up to 272K input tokens run at $2 input, $0.10 cached input, and $10 output, but any request exceeding 272K input tokens shifts to $4 per 1M input tokens, $0.20 per 1M cached input tokens, and $15 per 1M output tokens.

Cost of one request with 500K input plus 20K output tokens. GPT-6.1 Sol bills requests above 272K input tokens at its long-context rate.

In contrast, Claude Sonnet 5.5 bills the full 1M-token context window at standard rates. Anthropic bills a 900K-token request at the exact same rate as a 9K-token request. Gemini 4 Argon also maintains one rate across its whole context window, with no separate tier above 200K.

A single request with 500K input tokens and 20K output tokens shows the effect of the 272K threshold. Claude Sonnet 5.5 costs $1.20, and Gemini 4 Argon costs $1.20 until November 30. GPT-6.1 Sol hits the long-context tier and costs $2.30. From December 1, the same request costs $2.40 on Gemini 4 Argon, which leaves Claude Sonnet 5.5 as the cheapest of the three at list price for long prompts.

How do caching and batch change the math?

All three providers list cached input tokens at $0.10 per 1M tokens through November 30. However, Anthropic charges for cache writes in addition to read tokens. Cache writes on Sonnet 5.5 cost $2.50 per 1M tokens for a 5-minute cache or $4 per 1M tokens for a 1-hour cache, meaning your actual savings depend on how frequently you reuse a prompt prefix.

Argon handles caching differently by removing explicit cache controls. Google does not support cachedContents or caches.create on Argon, relying entirely on implicit caching that activates automatically for prompts of at least 4,096 tokens. You cannot pin a cache explicitly with Argon, so cache savings depend on how often Google matches a repeated prompt prefix.

Batch options cut base rates in half across all three providers. Through November 30, Argon batch runs at $1 input and $5 output per 1M tokens, matching Sonnet 5.5 Batch and GPT-6.1 Sol Batch. On December 1, Argon batch doubles to $2 input and $10 output, while Sonnet 5.5 and GPT-6.1 Sol batch prices list at $1 and $5 as of October 23 (up to 272K input tokens on GPT-6.1 Sol).

What do you need to change in your code for Argon?

Moving existing code to Gemini 4 Argon requires adjusting generation parameters according to Google's migration guide. Argon ignores temperature, top_p, and top_k, so developers should remove these parameters from API calls entirely.

Instead, Argon introduces thinking levels of low, medium, and high. Google notes that the medium setting is the default and acts as "your main control over quality, latency, and token use". Because thinking tokens count against billed output tokens, higher thinking levels increase your overall per-request invoice.

A single Argon response can exceed 64K tokens, up to 1M minus the input tokens. Google recommends setting max_output_tokens to at least 32,768 because the limit covers thinking and output together. If you use Grounding with Google Search, Google provides 5,000 free requests per month shared across Gemini 3 and newer models, then charges $14 per 1,000 requests.

How do you compare all three with one API key?

Tokely provides access to all three models through a single balance and an OpenAI-compatible Chat Completions endpoint. Switching between providers requires updating only the model ID to gemini-4-argon, claude-sonnet-5-5, or gpt-6.1-sol. You can inspect responses side by side using the Playground.

Tokely prices listed on October 23, 2026 offer discounts below direct provider rates. Gemini 4 Argon lists at $1.40 input, $7.00 output, and $0.07 cached per 1M tokens. Claude Sonnet 5.5 lists at $1.50 input, $7.50 output, and $0.075 cached per 1M tokens. GPT-6.1 Sol lists at $0.80 input, $4.00 output, and $0.04 cached per 1M tokens.

The workload of 1M input tokens and 250K output tokens costs $3.15 on Argon, $3.38 on Sonnet 5.5, and $1.80 on GPT-6.1 Sol on Tokely. Tokely prices can change, so check current rates on the Tokely models page.

Sources

Price details and migration rules are documented in the official vendor publications, including Gemini API pricing, Gemini API changelog, What's new in Gemini 4 Argon, Claude pricing, OpenAI API pricing, and our price study Are AI APIs Getting Cheaper?.

Originally published at tokely.me.

DeepSeek Banned From U.S. Federal Agencies: Who It Affects and What to Use Instead

Tokely — AI API Platform — Thu, 22 Oct 2026 08:04:12 +0000

Short answer: The Department of Homeland Security ordered federal civilian agencies to stop buying DeepSeek products and to remove them, including third-party products built using DeepSeek implementations, from their IT. Private companies are not directly restricted, but software vendors to civilian agencies are affected. At list prices, GPT-5 nano and GPT-6 Luna cost less than DeepSeek V4.1 Flash on a typical workload.

What exactly did DHS order?

Federal Register notice 2026-21447, filed on October 19, 2026, and published October 20, 2026, publishes notice of the order under Docket DHS-2026-0628. The Secretary of Homeland Security issued a formal order titled Notice of Order Regarding Exclusion and Removal of DeepSeek Products From Federal Civilian Executive Branch Information Technology Systems and Procurements.

The order has two parts. First, it requires the exclusion of information technology products and services developed by Hangzhou DeepSeek Artificial Intelligence Co., Ltd, including its affiliated entities defined under 48 CFR 2.101, from federal civilian procurements. Second, it mandates the active removal of existing DeepSeek and affiliate software, as well as third-party products and services built using DeepSeek implementations, from federal civilian executive branch information technology systems.

The statutory basis relies on the Federal Acquisition Supply Chain Security Act of 2018, codified at 41 U.S.C. 1321-1328, alongside implementing regulations in 41 CFR 201-1. Homeland Security acted following a formal review and recommendation by the Federal Acquisition Security Council. According to press reports, this proceeding represents the first time the government has deployed this supply chain security authority against an artificial intelligence enterprise.

Press reporting from CyberScoop, The Next Web, and Bloomberg Government indicates that the signed order itself is dated July 24, 2026. These reports note government concerns regarding foreign data access risks and underlying model vulnerabilities. The published notice itself focuses on supply chain security protocols and does not identify a specific data leak occurrence.

Who is affected, and who is not?

The order applies strictly to federal civilian executive branch information technology systems and federal procurements. Commercial enterprises, private startups, and individual consumers face no direct restrictions under the explicit terms of the notice. This article is not legal advice.

Software vendors that sell into civilian agencies are the group most affected in practice. The order specifically extends beyond direct DeepSeek subscriptions to include any third-party software products or digital services developed using DeepSeek implementations. Teams that serve civilian agency contracts should check whether any product they deliver relies on DeepSeek models.

The federal notice formalizes restrictions that had already started emerging across individual state and defense entities. According to press reports, New York, Tennessee and Virginia had already enacted their own limitations on DeepSeek software. Within the federal government, the Navy and the Department of Commerce had earlier instituted bans covering personnel work devices.

The regulatory announcement arrived during the same week DeepSeek introduced its V4.1-Flash-1017 model, which reached 959 points on Hacker News. The Hacker News thread about the ban drew 541 comments. The signed order is published on regulations.gov under docket DHS-2026-0628.

Are there cheaper alternatives?

Two OpenAI models undercut DeepSeek V4.1 Flash on list price. Official prices verified on October 5, 2026, show that a sample workload of 1 million input tokens and 250,000 output tokens costs $0.300 on DeepSeek V4.1 Flash, based on $0.15 per million input tokens and $0.60 per million output tokens. In comparison, GPT-5 nano completes that identical workload for $0.150, charging $0.05 per million input tokens and $0.40 per million output tokens.

Cost of 1M input plus 250K output tokens at official list prices, verified October 5, 2026. Price is not capability: test on your own prompts.

GPT-6 Luna also costs less than DeepSeek V4.1 Flash, pricing the same workload at $0.225 through rates of $0.10 per million input tokens and $0.50 per million output tokens. Mid-tier alternatives from the same providers command moderately higher rates, with GPT-5.6 Luna totaling $0.500 and GPT-5.4 nano landing at $0.512 for the same 1.25-million-token volume. Further up the price scale, Gemini 3.5 Flash Lite reaches $0.925, while DeepSeek V4 Pro costs $1.155 using its base rates of $0.66 per million input tokens and $1.98 per million output tokens.

Larger models cost more: Gemini 3.8 Flash comes to $1.688 for the same workload. Claude Haiku 4.5 rounds out the monitored group at $2.250 for the combined 1 million input and 250,000 output tokens.

Context caching shifts the economic balance when applications reuse extensive system prompts or reference documents. DeepSeek V4.1 Flash applies a 98 percent discount to cached inputs, dropping cached input rates to $0.003 per million tokens. OpenAI applies a 90 percent caching discount, resulting in cached input rates of $0.005 per million tokens for GPT-5 nano and $0.01 per million tokens for GPT-6 Luna.

When an engineering team caches 80 percent of input tokens, the net workload costs adjust noticeably across providers. Under an 80 percent cache scenario on that standard workload, GPT-5 nano costs $0.114, GPT-6 Luna costs $0.153, and DeepSeek V4.1 Flash costs $0.182. Price metrics do not measure model reasoning or task performance, so engineering teams should test prospective replacements against their specific application prompts before committing to a provider transition.

How do you switch models without rewriting code?

A single OpenAI-compatible API key on Tokely provides unified routing and billing across DeepSeek, OpenAI, Google, and Anthropic models. There is no new SDK, account or invoice per vendor. Migrating an existing integration from DeepSeek to another model requires only an update to the model ID string within your client configuration.

Test candidates on your own prompts before you switch production traffic. In the Playground you can run the same prompt on each candidate model first. You can review available target identifiers, pricing, and provider compatibility directly on the Tokely models index.

Sources

Regulatory documentation and reporting details can be found in Federal Register notice 2026-21447, alongside news coverage from CyberScoop and The Next Web, with API cost figures sourced from the Tokely pricing study Are AI APIs Getting Cheaper?.

Originally published at tokely.me.

Claude API 2026-10-21: What Breaks and How to Upgrade

Tokely — AI API Platform — Thu, 22 Oct 2026 08:04:12 +0000

Short answer: Anthropic released API version 2026-10-21 on October 21, 2026. Requests on the new version that send temperature, top_p or top_k, a document in an assistant message, or citations in a user message return 400. New SDK majors send the new version by default and pass your key as Authorization: Bearer. Requests that stay on 2023-06-01 keep working.

What changed on October 21?

Anthropic released API version 2026-10-21 on October 21, 2026, the first new version since 2023-06-01. Eight official SDK and CLI libraries released new major versions simultaneously to send 2026-10-21 by default. These releases include Python SDK 2.0.0, TypeScript SDK 1.0.0, C# SDK 13.0.0, Go SDK 2.0.0, Java SDK 3.0.0, PHP SDK 1.0.0, Ruby SDK 2.0.0, and CLI 2.0.0. The new versions are licensed under Apache 2.0 instead of MIT.

Direct API callers opt in explicitly by passing the header anthropic-version: 2026-10-21. Older SDK major releases remain functional and continue pinning requests to the 2023-06-01 version. On Amazon Bedrock, version 2026-10-21 is available only for Claude 4.7 and later models.

Which requests now return 400?

Sending temperature, top_p, or top_k to the Messages API, token counting endpoints, or Message Batches returns a 400 error under version 2026-10-21. The API rejects requests containing any of these three fields even if the payload sets them to their default values. Without them, requests sample with the defaults, including a temperature of 1.0. Before, this request worked; on 2026-10-21 it returns 400:

{
  "model": "claude-sonnet-4-6",
  "messages": [
    {
      "role": "user",
      "content": "Analyze these logs."
    }
  ],
  "temperature": 0.2,
  "max_tokens": 1024
}

After, the same request without the sampling parameter:

{
  "model": "claude-sonnet-4-6",
  "messages": [
    {
      "role": "user",
      "content": "Analyze these logs."
    }
  ],
  "max_tokens": 1024
}

Models that already accept only defaults, such as Claude 4.7 and later, sample exactly as before. On models that accept other values, such as Claude Sonnet 4.6, a request that lowered temperature loses that effect, and no other setting replaces it. Callers dependent on non-default values must stop sending them or keep those specific requests on 2023-06-01.

Placing a document block directly within an assistant message returns an HTTP 400 response. Client payloads must send document blocks inside user messages instead. The API still accepts document blocks nested inside another block in assistant messages, such as results returned by a web fetch tool.

Supplying a text block that contains a non-empty citations array inside a user message also generates a 400 error. This restriction applies whether the text block appears directly in a user message or inside a search_result block. The API continues to accept citation arrays inside assistant messages, as well as the setting "citations": {"enabled": true} on documents and search results.

What changes in the new SDKs?

API keys are now sent as Authorization: Bearer headers instead of X-Api-Key. The Claude API accepts either header format, so direct callers require no modifications. Any proxy or gateway that reads X-Api-Key must be updated to read Authorization, though AnthropicFoundry still sends x-api-key.

MessageParam in the Python SDK is now a union of UserMessageParam, AssistantMessageParam, and SystemMessageParam. Beta versions split following the identical design pattern. Calling MessageParam directly raises a TypeError at runtime, requiring Python developers to write messages as standard dictionaries.

# Before: Python SDK 1.x
from anthropic.types import MessageParam

message = MessageParam(role="user", content="Hello")

# After: Python SDK 2.0.0
from anthropic.types import MessageParam

message: MessageParam = {"role": "user", "content": "Hello"}

Text Completions is removed from the TypeScript, Go, Java, and Ruby SDKs, as well as the CLI where ant completions create has been removed. Applications calling legacy completion endpoints must migrate their payloads to the Messages API.

The non-beta Models methods no longer accept beta flags across SDK clients. To send beta headers, call the same methods on client.beta.models. In Python, this requires calling client.beta.models.list(betas=[beta]).

The TypeScript and Ruby SDK tool runners drop client-side compaction via compactionControl in favor of server-side compaction. Applications enable server-side compaction by providing betas: ["compact-2026-01-12"]. It is configured through context_management edits of type compact_20260112, with a trigger of at least 50,000 input tokens.

Which Admin API fields were renamed?

In 2026-10-21 the Admin API renames five response fields and the Claude Enterprise Analytics API renames two; the old names are gone. Role-based access control requests now reference role_ids instead of roles on RBAC groups. RBAC group members replace group_id with rbac_group_id, while RBAC roles rename name to display_name.

Organization and workspace rate-limit entries replace group_type with group.type. In the Claude Enterprise Analytics API, per-user usage and cost reports replace actor.email with actor.email_address. In addition, activity summaries responses rename summaries to data.

API key responses replace workspace_id with a scope field. Single-workspace API keys store the identifier under scope.workspace_id. An all-workspaces key returns a scope of {"type": "organization"} with no workspace_id.

How do you upgrade safely?

Upgrading to 2026-10-21 follows three steps from the official migration guide. First, switch to 2026-10-21 by updating your SDK dependency to the new major version or by adding the header. Second, fix breaking changes that affect your implementation, including removing sampling parameters and updating dictionary formats. Third, run your test suite against 2026-10-21 before releasing updates to production.

Updating SDK dependencies switches client calls to the new version header automatically. In Python environments, developers upgrade packages via standard package management.

pip install --upgrade "anthropic>=2.0.0"

Direct HTTP callers can test individual payloads by setting the anthropic-version header manually. This validates that request schemas comply with the new requirements before making code changes in production.

curl https://api.anthropic.com/v1/messages \
  -H "anthropic-version: 2026-10-21" \
  -H "Authorization: Bearer $ANTHROPIC_API_KEY" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Ping"}]
  }'

Does this affect Claude Code or apps using Tokely?

Tokely's /v1/messages endpoint at base URL https://api.tokely.me accepts API keys sent via Authorization: Bearer or x-api-key. Because the gateway accepts both authentication schemas, new major SDKs authenticate without changes. Tokely forwards the anthropic-version header you send and defaults to 2023-06-01 when absent, so plan for the same 2026-10-21 rules when you upgrade your SDK.

To point Claude Code at Tokely, see the Claude Code guide.

Sources

This guide references the Anthropic release notes, the official migration document Migrating to API version 2026-10-21, and the protocol documentation on API versions.

Originally published at tokely.me.

What Is Tokely? One API for GPT, Claude, Gemini and 130+ Models

Tokely — AI API Platform — Thu, 22 Oct 2026 07:15:40 +0000

Short answer: Tokely (tokely.me) is a hosted LLM gateway. You get one OpenAI-compatible API key and one prepaid USD balance for 137 text, image, video and audio models. They come from 14 model developers, including OpenAI, Anthropic, Google, xAI, DeepSeek, Moonshot and Qwen. Published rates are up to 85% below official list prices on selected models and 30% lower at the median, with no subscription and no platform fee.

What does it cost compared to official prices?

The examples below use a matched workload of 1M uncached input plus 250K output tokens. Tokely rates are dated October 12, 2026; reference prices were checked October 5 and October 15, 2026.

Grok 4.3: $0.1875 input and $0.375 output per 1M tokens on Tokely, against $1.25 and $2.50 from xAI. That is 85% less on the example workload.

GPT-5.4 Mini: $0.30 and $1.80 on Tokely, against $0.75 and $4.50 from OpenAI, 60% less. Claude Haiku 5.5: $0.042 and $0.21, against $0.10 and $0.50 from Anthropic, 57.6% less.

Claude Sonnet 5.5: $1.50 and $7.50 on Tokely, against $2 and $10 on the OpenRouter listing, 25% less before OpenRouter's platform fee. Live rates for every model are on the pricing page.

There is no subscription, no monthly minimum and no platform fee. You top up a prepaid balance and pay only for the tokens or media you generate. Images start at $0.0054 per image and video at $0.01116 per second; embeddings are billed on input tokens only. The cost calculator estimates a workload before you spend anything.

How do you connect?

Point any OpenAI-compatible client at https://api.tokely.me/v1 and authenticate with your Tokely key. Your request format stays the same.

from openai import OpenAI

client = OpenAI(base_url="https://api.tokely.me/v1", api_key="<YOUR_TOKELY_API_KEY>")
reply = client.chat.completions.create(
    model="gpt-5.4-mini",
    messages=[{"role": "user", "content": "Hello, Tokely!"}],
)
print(reply.choices[0].message.content)

To switch to Claude, Gemini or DeepSeek, change the model ID. No new account, SDK or invoice.

Claude Code connects through the native Anthropic Messages API (/v1/messages) with streaming, tools and prompt caching. The Claude Code guide shows how to map the Sonnet, Opus and Haiku slots to Tokely model IDs.

ANTHROPIC_BASE_URL=https://api.tokely.me ANTHROPIC_AUTH_TOKEN='<YOUR_TOKELY_API_KEY>' claude

Which models are available?

The catalog lists 137 live models, 114 of them for text. The same key also covers image models such as Nano Banana 2, Nano Banana Pro, GPT Image 2, Seedream 5.0 Pro, Qwen Image 3.0 and FLUX.1 Kontext Pro, and video models such as Veo 3.1, Grok Imagine Video, Seedance 1.5 Pro and Wan 2.6.

Speech synthesis and asynchronous audio tasks run on the same balance. Embeddings are served at /v1/embeddings for text-embedding-3-small, text-embedding-3-large and text-embedding-ada-002.

New models join the same key and balance as they ship. Each model page lists its endpoints, parameters, streaming support and current price, and GET /v1/models returns every enabled ID.

What happens when a provider fails?

Tokely has five routing modes: Balanced, Lowest cost, Fastest, Most reliable and Fixed. Set a default in account settings or choose one per request with the X-Tokely-Routing header. Lowest cost compares current route quotes for a normalized token mix. Fixed keeps the selected route and fails instead of substituting a model.

If a compatible route returns an eligible error before work is accepted, the gateway retries another configured route for the same model. A failed route doesn't have to become a failed request. Fallback never silently duplicates paid work: accepted media tasks stay pinned to their route, and partial streams are not replayed.

How do you control spending?

Budgets are enforced inside the gateway, before a request is billed. Daily and monthly account budgets in UTC apply across every key and the Playground. Each key can also have its own lifetime budget, model allowlist, IP restrictions and expiry date.

Before generation, Tokely reserves the estimated cost, then settles actual usage and releases the rest. A request that would exceed a limit is rejected with a distinct error instead of being billed.

Every response carries an X-Request-ID that links to its dashboard log, with the model, token usage, routing mode, attempt outcomes, duration, HTTP status and billed cost. Usage can be exported, and signed webhooks report events to your backend.

What happens to your data?

Tokely doesn't store API prompts or completions, only the usage metadata needed for billing. Business customers can sign the Data Processing Addendum. The privacy policy and subprocessor list are public.

Is Tokely an OpenRouter alternative?

Yes. Both give one key for many models. Tokely charges no platform fee on top-ups, and on Claude Sonnet 5.5 its published token rates are 25% below the OpenRouter listing. The full comparison is in OpenRouter vs Tokely.

How do I pay?

Open Dashboard → Billing and top up through the hosted crypto checkout. Deposits range from $10 to $10,000 in USD equivalent. Funds become available after the payment settles, and one balance serves all your API keys. Tokely is pay as you go with no subscription; for volume terms, write to sup@tokely.me.

How do I get started?

Create an account and an API key, add funds from $10, then change your base URL to https://api.tokely.me/v1 and follow the quickstart. The Playground uses the same balance and budgets, so you can compare models on real prompts before writing code.

Originally published at tokely.me.

Are AI APIs Getting Cheaper? Official Prices of 66 Models, 2024-2026

Tokely — AI API Platform — Thu, 22 Oct 2026 07:15:39 +0000

Research scope: This study compares official AI API list prices as of October 5, 2026. Model release dates are used to compare pricing across model generations, not to reconstruct historical price changes.

Short answer: At current official prices, the newest top-tier model of 66 we compared lists output tokens at 6.25x the price of an April 2025 flagship: $50 versus $8 per million. Workhorse models from different generations sit at the same $10, and the cheapest models from 2024 and 2026 cost about the same, $0.40 to $0.60. On most current models, cached input is 90 to 98% cheaper than fresh input.

What did we measure?

Our dataset tracks 66 production language models released between April 2024 and September 2026 across eight commercial model developers. OpenAI accounts for 38 models, Anthropic accounts for 12, Qwen provides five, Google provides five, Moonshot has two, DeepSeek has two, MiniMax has one, and xAI has one.

For each model, we gathered the official list price per 1 million input tokens, 1 million output tokens, and 1 million cached-input tokens, verified on October 5, 2026. We also recorded each model's official release date, which we use only to group models by generation.

The findings are organized around four charts: flagship pricing, tier distribution, caching discounts and output-to-input ratios. All figures are list prices in US dollars per 1 million tokens. The full dataset is available as a CSV file so you can check every number.

Finding 1: The flagship premium

Output price of each developer's top model and the cheapest model, by release date. Log scale. Current official list prices, verified October 5, 2026.

We call the main pattern the flagship premium: at today's prices, each newer top-tier model lists far above the previous generation's flagship, while workhorse and budget models of different generations cost about the same.

OpenAI's top general models show it across eight generations. At current list prices, the May 2024 GPT-4o snapshot costs $15 per 1 million output tokens and the November 2024 snapshot $10. GPT-4.1 (April 2025) is the cheapest flagship at $8. Each later generation lists higher: GPT-5 (August 2025) at $10, GPT-5.2 (December 2025) at $14 and GPT-5.4 (March 2026) at $15.

The gap widens in the two newest generations. GPT-5.5 (April 2026) lists at $30 per 1 million output tokens and GPT-6 Astra (September 2026) at $50. Today GPT-6 Astra's output price is 6.25x that of GPT-4.1, released 17 months earlier.

Above the flagships sits OpenAI's Pro tier. GPT-5 Pro (October 2025) lists at $120 per 1 million output tokens, GPT-5.2 Pro at $168, and GPT-5.4 Pro and GPT-5.5 Pro at $180, the highest output price in the dataset.

Anthropic reaches the same ceiling differently. Every Opus generation from Claude Opus 4.5 (November 2025) to Claude Opus 5 (July 2026) lists at $25 per 1 million output tokens. Instead of pricing Opus higher, Anthropic added a tier above it: Claude Fable 5 (June 2026) and Claude Fable 5.1 (September 2026) list at $50.

Finding 2: The workhorse tier sits at $10

Output price of the newest model in each tier, October 2026. Log scale.

While the newest top-tier models list at $50, the workhorse tier sits at $10 per 1 million output tokens across generations. GPT-6.1 Sol (September 2026) lists at $2 input and $10 output, the same output price as GPT-5 (August 2025).

Anthropic's newer mid-tier models list lower than older ones. Claude Sonnet 4.6 (February 2026) lists at $15 per 1 million output tokens, while Sonnet 5 (June 2026) and Sonnet 5.5 (September 2026) list at $10. Claude Opus 5.5 (September 2026) lists at $4 input and $20 output, below every earlier Opus at $5 and $25.

Developers now ship explicit three-tier families. OpenAI's GPT-6 family lists Astra at $50, Sol at $10 and Luna at $0.50 per 1 million output tokens. Across all developers, the newest models span a 100x output price range: Claude Fable 5.1 and GPT-6 Astra at $50 at the top, GPT-6 Luna at $0.50 at the bottom.

In between, Kimi K3 lists at $15 per 1 million output tokens, Grok 4.7 at $6, Claude Haiku 4.5 at $5, Gemini 3.8 Flash at $3.75, Gemini 3.5 Flash Lite at $2.50, DeepSeek V4 Pro at $1.98 and DeepSeek V4.1 Flash at $0.60.

Finding 3: Budget models from 2024 and 2026 cost the same

The cheapest output prices are nearly identical across generations. GPT-4o mini (July 2024) lists at $0.60 per 1 million output tokens, GPT-4.1 nano (April 2025) and GPT-5 nano (August 2025) at $0.40, and the September 2026 budget models GPT-6 Luna and DeepSeek V4.1 Flash at $0.50 and $0.60.

Input prices at the bottom sit in a similar band. GPT-5 nano lists input at $0.05 per 1 million tokens, GPT-6 Luna at $0.10 and DeepSeek V4.1 Flash at $0.15. Across generations, the cheapest input price stays between $0.05 and $0.15.

This study compares list prices, not capability. A budget model from September 2026 may handle harder tasks per token than one from July 2024; we did not test that.

Finding 4: Cached input costs 10 to 50x less on most current models

Discount on cached input versus fresh input at current list prices, by model release date. OpenAI highlighted; other developers in grey.

Cache discounts differ most between generations. At current prices, OpenAI's cached-input discount is 50% on GPT-4o mini (2024), 75% on GPT-4.1 (April 2025), 90% on GPT-5 (August 2025) and 95% on GPT-6.1 Sol (September 2026). A 95% discount makes cached input 20x cheaper than fresh input.

Anthropic lists a 90% cached-input discount on Claude Opus 4.5 through Opus 5, 95% on Claude Opus 5.5 and Claude Sonnet 5.5, and 97.5% on Claude Fable 5.1. DeepSeek V4.1 Flash lists 98%: $0.003 cached versus $0.15 fresh input.

A few developers discount less: Grok 4.7 lists 75% off, MiniMax M3 80% and Kimi K2.6 83%. On most 2026 models, though, cached input costs 10x to 50x less than fresh input.

The difference is easy to see on a long context. On GPT-6.1 Sol, a 100,000-token context costs $0.20 as fresh input at $2 per 1 million tokens. Cached, the same context costs $0.01.

Finding 5: Newer models price output at 5x input

Output price divided by input price at current list prices, by model release date. OpenAI in black; other developers in grey.

The output-to-input price ratio differs by generation. GPT-4 Turbo (April 2024) lists output at 3x input. OpenAI models from GPT-4o to o4-mini use 4x, the GPT-5 family (August 2025 to February 2026) 8x, GPT-5.4 and GPT-5.5 6x, and the GPT-6 family 5x.

Other developers' current models use the same multiple. Every Anthropic model in our dataset lists output at 5x input, and so do Gemini 3.6, 3.7 and 3.8 Flash. DeepSeek uses 3x to 4x and Grok 4.7 3x.

Because output tokens cost three to eight times more than input tokens, output volume usually decides the bill. Workloads that generate long text, code or multi-step reasoning are the most sensitive to the output price.

What should teams do with this?

Route by tier. With a 100x spread between the newest top and budget models, send routine tasks like data extraction, classification, and short conversational turns to models in the $0.50 to $10 output price range. Reserve $50 models like GPT-6 Astra or Claude Fable 5.1 for the tasks that need them.

Design prompts for caching. Put system instructions, schemas and reference documents at the front of every request so they stay identical across calls. Cached input is 90% to 98% cheaper than fresh input on most current models, so every stable token at the front of a prompt pays off.

Forecast output, not input. Output tokens cost five times as much as fresh input tokens and up to two hundred times as much as cached input tokens. Tokely gives you one API key and one balance across all of these tiers, with routing modes and automatic fallback; compare rates on Tokely pricing and estimate a workload with the cost calculator.

Methodology and limitations

Prices in this study are official list prices verified on October 5, 2026. They are a snapshot, not a price history: release dates only group models by generation. Some models were repriced after release, such as OpenAI lowering o3 to $2 per 1 million input tokens and $8 per 1 million output tokens in June 2025, so a model's current price can differ from its launch price. Release dates come from official release notes, or the dated model identifier where no notes exist; the CSV records the source for each row.

The sample covers models tracked in Tokely's catalog, which weights it toward OpenAI with 38 of the 66 entries. We excluded realtime and audio models, batch and priority tiers, long-context surcharges and taxes. All prices are in US dollars per 1 million tokens.

Data and citation

The full dataset of 66 models includes developer names, model identifiers, release dates, input rates, output rates, cached input rates, and source verification URLs, and is available for download at ai-api-price-study-2026.csv. Cite as: Tokely (2026). Are AI APIs Getting Cheaper? Official Prices of 66 Models, 2024-2026. https://tokely.me/blog/ai-api-price-trends-2026

Originally published at tokely.me.