Your agent is stuck. Call a specialist.

The problem#

If you code with an AI agent every day, you know this loop.

Your agent hits an error. It patches something. The error changes shape. It patches again. Twenty minutes later you’re on attempt seven, the context window is full of failed fixes, and you still don’t know what broke.

Behind that loop is a second, quieter problem: the plumbing.

• Many keys, many accounts. Each provider has its own key, its own billing page and its own error format.
• No backup. When a provider is rate-limited or down, your tool just stops, in the middle of a session.
• No idea what anything cost. A monthly invoice tells you the total, not which request, tool or model spent it.

Inferiq is built to fix both: the plumbing first, then the loop.

What Inferiq is#

Inferiq is a gateway for coding agents. You get one key that reaches every coding model we serve, through one standard endpoint. On top of the gateway sit fix agents: specialists you hand a stuck error to, which return the cause and a patch.

1. One key, one endpoint, a model hosted for you

One OpenAI-compatible endpoint, with streaming and tool calls, backed by Qwen3.8-27B on Inferiq’s own GPUs. Point Cline, OpenCode, Cursor or any OpenAI SDK at it and it works. If an attempt fails, it’s retried before your tool notices.

2. Fix agents

When your own agent keeps circling a bug, send the error to a specialist. It reads the log and the files involved and returns three things: the cause, a patch, and a way to check that the patch works. It never runs commands on your machine. It hands you a patch, and you decide.

3. Pay per call, with a receipt for every call

One balance in US dollars. Every request and every fix is paid from it. No subscription, no monthly minimum, no card on file. Fixes are quoted before they run, with a maximum they can’t go over. Every charge, including every refused or failed request, gets a receipt.

What’s live today, and what’s coming#

We’d rather be precise than impressive. The hosted gateway is in early access, and this is where things stand.

The roadmap has every phase and its exit criteria.

How it works#

The life of a request

Every request takes the same path through the gateway. Once you know the path, you know what Inferiq checks, where a request can fail, and what you pay for.

1. Your tool sends a request

   A standard OpenAI-format chat request, with your Inferiq key in the Authorization header.

2. The key is checked

   It’s hashed and looked up. Revoked keys are refused, and the key’s per-minute rate limit is applied.

3. The request is validated

   It needs a model, at least one message and well-formed tool calls.

4. Models are picked

   The model has to be one this key may use. An exact model is used as named; an alias expands into its models, in order. Models that can’t handle this request are skipped.

5. Money is checked

   Your balance has to cover the request’s worst-case cost, and the key’s daily limit needs room.

6. The model is called

   If it’s rate-limited, times out, is overloaded or down, the next model in the list is tried before anything reaches you.

7. You’re charged and a receipt is written

   The tokens actually used are priced, your balance is debited and the receipt saved, in one database transaction.

8. You get your answer

   A normal chat completion or stream. The headers name the model that answered and carry the receipt ID.

Aliases: pick how hard the model thinks

Every alias runs on Qwen3.8-27B. The alias sets how much it reasons before answering. You can also name the model, qwen/qwen3.8-27b, and set reasoning_effort yourself.

Deeper reasoning writes more tokens, so inferiq/best costs more per request than inferiq/fast. The model sleeps when nobody is using it: the first request after a quiet spell can take a few minutes while it wakes up.

Retry rules

Retries

Rate limits, timeouts, overload and outages are retried once.

Stops

A request the model rejects as invalid isn’t retried; you get the model’s message.

Bounded

At most three attempts per request. Every attempt is on the receipt, and only the one that answered is charged.

Never mid-stream

Once tokens have reached you, a failure ends the stream with an error instead of starting over.

Receipts

Every request writes one receipt. It shows:

• the model you asked for, and the model that answered
• every attempt, in order, with its result and duration
• tokens in and tokens out
• the cost, to the millionth of a dollar
• your balance before and after
• how long was spent inside Inferiq versus waiting on the model
• which key made the call

Receipts never contain your prompt or the model’s answer.

What gets stored, and what doesn’t

Limits, balances and retries are enforced in plain gateway code, before and after every model call. Inferiq never relies on asking a model to behave. The full technical path is in How it works.

How fix agents work#

Fix agents are for the moment your own agent gives up, or should have.

Quick Fix

One error and its stack trace, plus the files it points at. Returns the cause and a small patch.

Build Doctor

Install, build and deploy failures: npm, pnpm, Next.js, Vite, Docker, Vercel. Checks package.json and the versions actually installed before it patches anything.

Every run follows the same four steps:

1. Quote

   You describe the problem in your own words and send the error and the files. You get back an estimate and a hard maximum. Quotes are free.

2. Hold

   When you approve the quote, the maximum is held from your balance.

3. Run

   The agent finds the cause, writes a patch and checks that every part of it matches the files you sent.

4. Charge

   You pay what the run actually cost, never more than the maximum. The rest of the hold goes back to your balance.

What to send

A fix is only as good as what the agent can read. Say in a few sentences what’s going wrong (what you were doing, what you expected, what you already tried), paste the error exactly as it was printed, and attach the files it points at. The agent reads your description first, so it fixes the problem you actually have.

TypeError: Cannot read properties of undefined (reading 'map')
    at OrderList (src/components/order-list.tsx:14:22)
    at renderWithHooks (react-dom.development.js:16305:18)

> next build
./app/(shop)/cart/page.tsx:3:10
Type error: Module '"next/navigation"' has no exported member 'useRouterState'.
Error: Command "npm run build" exited with 1

Each run picks one of three tiers:

What a fix costs, by tier. Your quote gives the exact estimate and maximum before anything runs.

Open Fix in the console, or call /v1/fix/quote from your own scripts. A failed run costs nothing. Common secrets in your logs and files are replaced with [redacted] before anything is sent, and .env files are left out. Type Fixer, Dependency Doctor and Test Fixer come next, and each has to clear the same patch-quality bar. The API calls and every result field are in Fix agents.

Guide: from zero to your first request#

1. Sign in with your wallet

   Open the console and connect an EVM wallet. Rabby is recommended, and any browser wallet that supports EIP-6963 (MetaMask and others) works too. Your wallet asks you to sign a short message. Before you sign, check that the domain in it matches the site you’re on.

   • Signing is free and happens off-chain.
   • It doesn’t send a transaction, approve tokens or move funds.
   • Inferiq will never ask for your seed phrase or private key.

2. Add balance

   Every request is paid from your balance, kept in US dollars. During early access, Inferiq credits it for you. You can also deposit ETH or USDG on Robinhood Chain, or ETH or USDC on Base from the wallet you signed in with. USDG and USDC count 1:1; ETH is converted at the US dollar rate when the deposit is credited. A 3% deposit fee is kept from each deposit.

3. Create an API key

   Go to API keys → Create key. Keys are free, so make one per tool or machine. Pick the models it may use (an alias like inferiq/balanced, exact model IDs, or all models), and optionally a daily spending limit. Copy the key: it starts with iq_ and is shown only once.

   .env

   Copy

   # .env: server side or your shell, never in browser code
   INFERIQ_BASE_URL=https://api.inferiq.run/v1
   INFERIQ_API_KEY=iq_••••••••

4. Check the key

   List the models your key may use. It’s the quickest check that the key and the base URL work.

   terminal

   Copy

   curl https://api.inferiq.run/v1/models \
     -H "Authorization: Bearer iq_…"

5. Send your first request

   terminal

   Copy

   curl $INFERIQ_BASE_URL/chat/completions \
     -H "Authorization: Bearer $INFERIQ_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{
       "model": "inferiq/balanced",
       "messages": [{"role": "user", "content": "Why does Array.prototype.map return undefined items?"}],
       "max_tokens": 400
     }'

   The response headers tell you which model answered and where the receipt is:

   response headers

   Copy

   HTTP/1.1 200 OK
   content-type: application/json
   x-inferiq-request-id: req_QXt5TzjNYPURUd0
   x-inferiq-receipt-id: rcpt_QXt5TzjNYPURUd0
   x-inferiq-model: qwen/qwen3.8-27b

   Because Inferiq speaks the OpenAI format, the official SDKs work as they are:

   index.ts

   Copy

   import OpenAI from "openai";
   
   // Inferiq speaks the OpenAI chat format, so the official SDK works as-is.
   const client = new OpenAI({
     baseURL: process.env.INFERIQ_BASE_URL,
     apiKey: process.env.INFERIQ_API_KEY,
   });
   
   const res = await client.chat.completions.create({
     model: "inferiq/balanced",
     messages: [{ role: "user", content: "Refactor this function to async/await." }],
   });

6. Look up the receipt

   terminal

   Copy

   curl $INFERIQ_BASE_URL/receipts/rcpt_QXt5TzjNYPURUd0 \
     -H "Authorization: Bearer $INFERIQ_API_KEY"

   You’ll see the tokens, the cost and your balance before and after. The same receipts are listed in the console under Receipts.

Connect your coding tool#

Base URL   https://api.inferiq.run/v1
API Key    iq_…
Model ID   inferiq/balanced

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "inferiq": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Inferiq",
      "options": {
        "baseURL": "https://api.inferiq.run/v1",
        "apiKey": "{env:INFERIQ_API_KEY}"
      },
      "models": {
        "inferiq/fast": { "name": "Inferiq fast" },
        "inferiq/balanced": { "name": "Inferiq balanced" },
        "inferiq/best": { "name": "Inferiq best" }
      }
    }
  },
  "model": "inferiq/inferiq/balanced"
}

OpenAI API Key              iq_…
Override OpenAI Base URL    https://api.inferiq.run/v1
Custom model                inferiq/balanced

export ANTHROPIC_BASE_URL="https://api.inferiq.run"
export ANTHROPIC_AUTH_TOKEN="iq_…"
export ANTHROPIC_MODEL="inferiq/balanced"
export ANTHROPIC_SMALL_FAST_MODEL="inferiq/fast"

The console’s Connect page has the same setup with your base URL filled in. More tools are in Connect your tool.

Set your limits and rules in the console#

The console is built so you never need the API docs to manage your account.

Home

Your balance, today’s spend and recent activity.

Fix

Hand an error to a fix agent and see the quote before it runs.

Receipts

Every request and fix, with its result (OK, Backup used or Failed) and why.

Usage & limits

Spend by day and by model, plus a monthly spending limit.

Wallet

Your balance, what’s held for running fixes, and deposits.

Connect

Ready-to-paste setup for Cline, OpenCode, Cursor, Claude Code and curl.

API keys

Create, limit and revoke keys.

Models

What each model costs and what it’s good at.

Model rules

For each alias: its model, whether a failed attempt is retried, and how many attempts it gets.

There’s also a built-in agent panel (⌘J). Type what you want in plain English, like “create a key for Cursor that can only use inferiq/fast”, or a command such as /keys create Cursor --models inferiq/balanced --limit 5. The agent shows what it’s about to do and asks you to confirm before it changes anything.

Tips for spending less and failing less#

• Give each tool its own key. You’ll see what Cursor spends versus your CI pipeline, and a leaked key only exposes one tool.
• Limit cheap tools to light reasoning. A background tool whose key only allows inferiq/fast can’t spend on deep reasoning by accident.
• Set max_tokens when your balance is low. Many coding tools leave it unset, and the model then defaults to 8,000 output tokens, so the worst-case check is larger than what you’ll actually pay.
• Keep conversations short. Every prompt token is billed, including history your tool resends, so starting a fresh chat for a new task saves money.

Limits and errors you might see#

All of these are refused before a model is called, so none of them cost anything. Every code is listed in Errors.

FAQ#

Do I need crypto?

You need an EVM wallet to sign in, and signing is free. During early access your balance is credited for you.

Is there a subscription?

No. Keys are free, and you pay per call from your balance at each model’s token price. No monthly minimum.

Does Inferiq keep my code?

Prompts and answers pass through to the model provider and back. Inferiq doesn’t store them, and they never appear in receipts or logs.

What if a model goes down mid-session?

With an alias, the next model answers and your tool keeps working. A stream that has already started ends with an error instead of switching models halfway.

Will a fix agent change my files?

No. It returns a patch and a way to check it. You decide whether to apply it.

Can I withdraw unused balance?

Not in the first release.

Which tools work today?

Anything that speaks the OpenAI chat format: Cline, OpenCode, Roo, Cursor’s chat, the OpenAI SDKs and curl, plus Claude Code through the Anthropic-format endpoint.

What’s next#

• Phase 2 (done): Quick Fix and Build Doctor, with quotes and a hard maximum, and the Anthropic-format endpoint for Claude Code. On 60 real errors they returned a correct patch 30/30 and 27/30 times.
• Phase 3 (live): deposits on Robinhood Chain and Base mainnet, with a wallet page and low-balance alerts.
• Phase 4 (in progress): the MCP server is live at /v1/mcp, so you can ask for a fix and approve its quote without leaving Claude Code or Cursor.
• Phase 5: Type Fixer, Dependency Doctor, Test Fixer, and npx inferiq fix.

Each phase ships when it meets its exit criteria, not on a date. A new fix agent, for example, ships only when it returns a correct patch most of the time on a set of real errors, measured against a baseline.