Install Jentic One Beta
Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the Cheaper Inference API, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.
Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.
Step 1: Jentic One Host machine
# On the machine that will host your Jentic One instance:
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fcheaperinference.com%2Fcheaperinference" | shStep 2: Agent machine
# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fcheaperinference.com%2Fcheaperinference" | sh
jentic register # connects your agent to your Jentic One instanceJentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.
What an agent can do with Cheaper Inference API.
Run OpenAI-compatible chat and text completions through a single wallet-backed endpoint
Send Anthropic-style messages and OpenAI responses with the same credential
Generate embeddings, images, and short videos from one inference surface
Compare model prices for a workload and count model supply under a price ceiling before spending
GET STARTED
Track per-request billing and daily spend across a workspace
Cap what an API key can spend by opening and closing task budgets
Score completed requests and report task outcomes to tune optimization techniques
Patterns agents use Cheaper Inference API for, with concrete tasks.
★ Agent Inference Through Jentic
AI agents that need model inference can call the Cheaper Inference API through Jentic instead of wiring a provider SDK. The agent runs chat completions, embeddings, or Anthropic messages against one wallet-backed endpoint, reads the request id and billed amount from each buffered response, and stays within a task budget the developer set. A pricing comparison lets the agent pick a model that fits the job before it spends.
Run a chat completion for a short summarization prompt, read the billed amount from the response, and confirm it stayed under the key's open task budget
Drop-in OpenAI and Anthropic Compatibility
Teams running on the OpenAI or Anthropic client libraries can repoint them at the Cheaper Inference API and keep their request shapes. The same endpoint serves chat completions, text completions, responses, embeddings, and Anthropic messages, so a codebase that mixes both vendors consolidates onto one credential and one wallet without rewriting prompts.
Repoint an existing OpenAI chat client at the base URL and run an identical chat completion request to confirm the response parses
Cost-Aware Model Selection
Before committing a workload, callers price it across models and count how many models fall under a chosen price ceiling. The comparison endpoint returns the projected cost per model so a workflow can route cheap, high-volume jobs to a budget model and reserve a stronger model for the calls that need it.
Price a 2000-token prompt across the available chat models and select the lowest-cost model that meets the context window
Spend Governance With Task Budgets
Workspaces cap inference spend by opening task budgets on individual API keys and closing them when work completes. Daily spend and per-request usage records let an operator reconcile what each key and task cost, and a workspace admin policy bounds what budgets members can open.
Open a task budget on a key, run a batch of embedding requests, then read the daily usage to confirm the spend is recorded
56 endpoints — the cheaper inference api routes openai- and anthropic-compatible inference requests across a range of models and bills each call against a prepaid wallet.
METHOD
PATH
DESCRIPTION
/v1/chat/completions
Create a chat completion
/v1/messages
Create an Anthropic-style message
/v1/embeddings
Create embeddings
/v1/images/generations
Generate images
/v1/models
List available models
/v1/models/compare
Price a workload across models
/v1/account/balance
Get the wallet balance
/v1/keys/{key_id}/task-budgets
Open a task budget on a key
/v1/chat/completions
Create a chat completion
/v1/messages
Create an Anthropic-style message
/v1/embeddings
Create embeddings
/v1/images/generations
Generate images
/v1/models
List available models
/v1/models/compare
Price a workload across models
/v1/account/balance
Get the wallet balance
/v1/keys/{key_id}/task-budgets
Open a task budget on a key
What agents get from Jentic-routed access to this vendor.
Setup
Wiring the Cheaper Inference API by hand means learning that it takes either a bearer token or an x-api-key header, optionally compressing large request bodies with gzip or brotli, and reconciling each call's cost from the response headers on streamed completions. Through Jentic you install once, import Cheaper Inference from the API Directory, store the token once, and your agent calls it.
Permission scoping
The Cheaper Inference API carries the model name inside the request body, so rules bound which operations your agent may call, not which model. Limit it to the inference operations it needs, such as chat completions and embeddings, so administrative ones like key revocation or wallet top-ups are not included unless you add them.
Credential isolation
Your Cheaper Inference token is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
Intent-based discovery
Agents search Jentic by intent such as run a chat completion cheaply or generate embeddings, and Jentic returns the matching Cheaper Inference operation with its input schema so the agent calls the right endpoint without reading the reference docs.
Alternatives and complements available in the Jentic catalogue.
Specific to using Cheaper Inference API through Jentic.
What authentication does the Cheaper Inference API use?
The Cheaper Inference API authenticates with a bearer token in the Authorization header or an API key in the x-api-key header, per its OpenAPI spec; when both are present the bearer token wins. A few model-listing endpoints under the public path are open and need no credential. Through Jentic the token is stored encrypted by your own Jentic One instance and injected at call time, so it never reaches the agent's context.
Can I generate images and video with the Cheaper Inference API?
Yes. The API exposes image generation and image editing endpoints plus a video generation endpoint alongside its text and embedding operations, all billed against the same wallet. Each buffered response returns a request id and the exact amount billed, so you can attribute the cost of a generation to a task.
What are the rate limits for the Cheaper Inference API?
The OpenAPI spec does not publish rate limits, and spend is bounded by your prepaid wallet balance rather than a fixed call ceiling. Check the vendor documentation at https://www.cheaperinference.com for current limits.
How do I run a chat completion with the Cheaper Inference API through Jentic?
Install Jentic One, then from the API Directory import Cheaper Inference and store your token once. Your agent searches by intent such as run a chat completion, and Jentic returns the chat completion operation with its input schema so the agent sends the prompt and reads the billed amount back. To run it on your own infrastructure, install Jentic One from its GitHub repo.
Is there a Cheaper Inference API MCP server?
You don't need an MCP server to give your agent the Cheaper Inference API. Jentic connects it directly from the API Directory: import it, store your token once, and your agent calls the chat, embedding, and image operations on demand. Operations are discovered when the agent needs them, so none of them sit in its context until a call is made.
Can I limit what my agent is allowed to do with the Cheaper Inference API?
Yes. Write a rule that allows only the inference operations the agent needs, such as chat completions and embeddings, so it can run those calls and nothing else. Account operations like revoking an API key, replacing the workspace policy, or starting a wallet top-up stay out of reach unless you add them, and every call the agent makes is logged.
For Agents
Run chat completions, Anthropic messages, embeddings, and image or video generation across many models through one wallet-backed endpoint. Compare model prices, read what each request cost, and cap spend with task budgets.
Use for: I want to run a chat completion on a cheaper model, Send an Anthropic-style message and record what it cost, Generate embeddings for a batch of documents, Compare the price of a prompt across several models
Not supported: Does not handle model training, fine-tuning, or vector storage. Use for routing inference requests across chat, embedding, image, and video models only.
The Cheaper Inference API routes OpenAI- and Anthropic-compatible inference requests across a range of models and bills each call against a prepaid wallet. It accepts the OpenAI chat, completion, responses, embedding, and image shapes alongside the Anthropic messages shape, so existing client code works against one wallet-backed endpoint. Every buffered response returns a request id and the exact amount billed, and the model endpoints let you compare prices or count supply under a ceiling before you spend. Usage records, savings snapshots, task budgets, and per-key spend controls round out the surface for teams that need to watch inference cost.
This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.
Base layer of spec validity and structural soundness.
Aggregated quality score from linter diagnostics, weighted by severity.
Percentage of `$ref` references that resolve successfully.
Checks whether the API description parses successfully and conforms to its declared specification (e.g., OpenAPI).
Structural correctness score based on schema issues using logarithmic dampening.
Clarity, completeness, and ingestion readiness for developers and tooling.
How richly the API is illustrated with examples.
Percentage of examples that conform to their schemas.
Percentage of operations with complete response definitions (success, client error, server error).
Health of API ingestion, bundling, and resolution within Jentic pipelines.
Semantic breadth, depth, and agent comprehension for AI systems.
Coverage of descriptions across API elements.
Coverage of RFC 9457 Problem Details for error responses.
Coverage, uniqueness, and casing consistency of operationIds for AI inference.
Coverage of summaries across operations/tags/info.
Functional utility, complexity comfort, and AI orchestration readiness.
Agent comfort level based on API operational and structural complexity.
Trust, risk posture, and security compliance.
Average quality of security schemes based on authentication method strength (weakest link for OAuth2).
Findability, semantic richness, and reasoning readiness.
Clarity and depth of descriptions across API elements.
Score it yourself
Every API in the directory is allowlisted, so you can re-score it with no key required.
npx @jentic/api-scorecard-cli score <openapi-url>