Finest

Finest is an AI model gateway designed for teams that want to reduce API spending without casually trading away quality. Instead of choosing a cheaper model simply because it performs well on a public benchmark, it examines the exact configuration of a request and only allows a cheaper route when published evidence supports the switch.

The idea is refreshingly practical: keep the prompts, model IDs, SDK, and request structure you already use, while putting an intelligent routing layer between your application and model providers. When a lower-cost configuration has enough evidence behind it, the request can be served there. If the evidence is missing, stale, ambiguous, or the quality checks fail, the original model remains in control.

For developers operating AI applications at meaningful scale, that distinction matters. A small reduction in the cost of thousands or millions of requests can become substantial, but only if the cheaper route does not quietly introduce worse answers, failures, or unpredictable behavior.

Key Features

• Evidence-based routing that can move eligible requests to lower-cost models.
• Support for OpenAI-shaped Chat Completions and Anthropic-shaped Messages APIs.
• No required rewrite of existing prompts, model IDs, or request bodies.
• Automatic escalation when a cheaper route fails a validator or quality requirement.
• Detailed receipts showing requested and served models, pricing, savings, and routing decisions.
• Multiple automatic selection profiles, including quality, balanced, economy, and document-oriented options.
• Request-level controls for residency, routing, task class, savings posture, and model demotion.
• Prepaid credits, request limits, token limits, and daily spending controls.
• Verification based on frozen test sets, paired model runs, and confirmation testing.
• A coding-agent installation path designed to keep API key material away from the agent.

User Interface

The experience is built around a developer-focused console rather than a consumer chat interface. From the available documentation, users can work with gateway keys, credits, receipts, verification records, policies, and operational controls. The setup is intentionally lightweight: issue a gateway key, configure the gateway URL and key, and change the client endpoint rather than rebuilding the application around a new API.

The dashboard approach makes sense for this type of product. Developers generally do not need another flashy workspace; they need to understand what happened to a request and why. The receipt and evidence concepts provide that operational visibility.

Accuracy & Performance

The strongest part of the routing approach is its conservative decision process. A lower-priced model is not selected merely because its average benchmark score looks impressive. The system checks the complete request configuration, including factors such as the model, provider, prompt, schema, decoding settings, effort, cache configuration, endpoint, and release information.

If a cheaper configuration is authorized but produces a validator failure or otherwise fails the required checks, the request can be escalated to the originally requested model. Streaming requests are also kept on the requested-model path rather than being demoted.

This makes the system particularly interesting for production applications where average benchmark performance is not enough. A model can be excellent on average and still perform badly on a small but important class of customer requests.

Capabilities

The platform can operate through a simple API-key swap or through a lightweight TypeScript shim. The latter can provide a direct fallback when the gateway proves that it refused a request before sending anything to the provider.

Its automatic model selection includes finest/auto, along with quality-first, balanced, economy, and document-oriented profiles. The selection process first applies hard constraints such as capability, context, output, streaming, and residency requirements before considering price.

Another useful capability is its evidence system. Routes can be classified as recommended, verified for specific examples, or proven in production, depending on the evidence available. This gives teams a more meaningful way to distinguish measured routing decisions from generic claims about model quality.

Security & Privacy

Security information is unusually explicit about both current protections and current limitations. The service states that it does not currently maintain a database column for gateway prompts or completion content, and uploaded, staging, and production content capture is blocked in the current release.

Infrastructure is described as running in AWS US East, with the database kept off the public network. TLS is used in transit, managed encryption is used at rest, and backups have a 14-day point-in-time recovery window. Workspace isolation uses row-level security, while secret material is handled through AWS KMS and deployment secret infrastructure.

There is also an important caveat for organizations evaluating the service: the security page states that no third-party audit exists yet. The documentation is transparent about this rather than presenting security claims as an independent certification.

Use Cases

This type of gateway is particularly useful for AI products that make a large number of model calls and need tighter control over inference costs.

• AI SaaS applications: Reduce unnecessary model spend while maintaining a defined quality threshold.
• Customer support systems: Route routine requests economically while keeping more demanding cases on stronger models.
• Document processing: Apply different model configurations depending on the requirements of the workload.
• AI agents: Control model selection across repeated automated requests and maintain receipts for operational review.
• Developer platforms: Add a routing layer without redesigning existing provider integrations.
• High-volume APIs: Identify opportunities for cost reduction across large numbers of requests.
• Production experimentation: Compare alternative configurations using controlled evidence instead of relying entirely on public benchmarks.

Pros and Cons

Pros

• Strong focus on evidence rather than simple benchmark rankings.
• Designed to minimize application-side integration changes.
• Clear receipts make routing and cost decisions easier to audit.
• Conservative fallback behavior helps protect quality.
• Supports both OpenAI-style and Anthropic-style API surfaces.
• Transparent documentation about current limitations.

Cons

• The current documentation makes clear that some production capabilities are not yet fully live.
• There is currently no third-party security audit.
• Streaming requests are not eligible for model demotion.
• Several advanced document and content-capture capabilities remain unavailable in the current release.
• Organizations requiring regional data residency beyond the stated infrastructure location may find the current setup restrictive.

Pricing Plans

The pricing model is built around savings rather than a conventional monthly subscription. The website states that provider pricing is passed through without markup and that customers pay nothing when no savings are proven. When eligible savings are demonstrated, the performance fee is stated as 25% of the savings.

For example, the documentation describes a hypothetical request with a $100 baseline and a $90 fully loaded routed cost. That creates $10 in eligible savings, resulting in a $2.50 performance fee and $92.50 paid overall.

One important detail should be kept in mind when evaluating the service today: the documentation states that the real payment rail, provider-invoice reconciliation, and customer fee collection are not yet proven live in the current checkout. The pricing model is therefore best understood alongside the product's current implementation status.

How to Use It

Getting started is intended to require very little change to an existing application. First, create a gateway key through the console. The key is shown only once, so it should be stored securely.

Next, configure the gateway URL and API key in the environment where your application makes model requests. With the standard integration, the main change is replacing the provider base URL and API key while leaving the request body and model ID intact.

Teams that want an additional fallback path can use the TypeScript shim. It can send a request directly to the provider when the gateway returns a response proving that no provider dispatch occurred. Once connected, developers can inspect receipts, evidence labels, costs, savings, and routing decisions to understand how requests are being handled.

Comparison with Similar Tools

Traditional AI gateways usually concentrate on giving developers access to multiple providers through a common interface, while model routers often focus on selecting an appropriate model based on price, capability, or performance. This product takes a more evidence-driven position.

The key difference is that a cheaper model is not supposed to win simply because it looks competitive in a benchmark. The exact request configuration needs supporting evidence before a demotion is authorized. That makes the approach attractive to teams that care about predictable quality and auditable decisions as much as raw API savings.

It also takes a conservative approach to failure. If the evidence does not justify a switch, the requested configuration remains in place. For businesses where a few difficult requests can have a disproportionate impact on customer experience, that philosophy can be more valuable than an aggressive cost optimizer.

Conclusion

Finest presents a thoughtful answer to one of the less glamorous problems in building AI products: paying too much for model calls without knowing exactly where savings are safe.

Its strongest quality is not simply automatic model selection. It is the emphasis on proving that a cheaper route is appropriate for the specific workload before making the switch. Receipts, evidence levels, conservative escalation, request controls, and transparent limitations make the product feel designed with production engineering in mind.

For developers and AI businesses with significant inference costs, it is worth exploring, particularly if the goal is to lower spending while keeping model quality measurable rather than leaving the decision to averages and assumptions.

Frequently Asked Questions (FAQ)

What does Finest do?

It acts as an AI model gateway that can route eligible requests to lower-cost model configurations when current evidence shows that the cheaper route meets the required quality and operational constraints.

Do I need to rewrite my AI prompts?

No. The documented integration is designed around changing the base URL and API key while keeping existing prompts, model IDs, SDKs, and request structures.

Does it always use the cheapest available model?

No. The routing system applies capability and other hard constraints first. A cheaper configuration is only eligible when the required evidence supports it.

What happens when the cheaper model fails?

The request can be escalated to the model that was originally requested. The system records the routing outcome so the decision can be audited later.

Does the service store prompts and completions?

The current security documentation states that gateway receipts contain metadata rather than prompt or completion content, and that production content capture is blocked in the current release.

Is there a third-party security audit?

Not yet. The security documentation explicitly states that no third-party audit exists at the current time.