Auxiliary Intelligence · For Agents

Private model endpoints,built for agents.

Your agent deploys a private open-weight model, gets a stable endpoint and an API key, and starts making inference calls — in minutes, with no human involvement after key generation. Pay per minute while it's active; we run everything underneath. OpenAI-compatible, so any framework drops in without changes.

🔒 Per-deployment API keys·⚡ ~3 min to a live endpoint·↔ OpenAI-compatible·📊 1,000 req/min/key
Quickstart

From zero to first inference

Five steps. Pick your language. Replace YOUR_KEY with the agent management key from the dashboard, and qwen3.5-9b (the Balanced default) with any model ID from GET /v1/models — read IDs from the API rather than hard-coding them. Upgrading older code? See the migration guide.

  1. 1. Deploy a private model

    Pick a model ID from GET /v1/models (Balanced is the default tier). Returns immediately with status: deploying. Save the deployment_id.

    curl -X POST https://api.auxen.ai/v1/deploy \
      -H "Authorization: Bearer YOUR_KEY" \
      -H "Content-Type: application/json" \
      -d '{"model":"<balanced-default>","throughput":"standard"}'
  2. 2. Wait for ready

    Poll the deployment until status is 'ready' (usually a few minutes). Save the api_key — that's the inference credential.

    DEP=inst_xxxxxxxxxxxx   # deployment_id from step 1
    while :; do
      RESP=$(curl -s -H "Authorization: Bearer YOUR_KEY" \
        https://api.auxen.ai/v1/deployments/$DEP)
      STATUS=$(echo "$RESP" | jq -r '.data.deployment.status')
      [ "$STATUS" = "ready" ] && break
      sleep 15
    done
    DEPKEY=$(echo "$RESP" | jq -r '.data.deployment.api_key')
  3. 3. Make an inference call

    Use the per-deployment auxk_ key (NOT your management key) against /v1/{deployment_id}/chat or the OpenAI-compatible /v1/{deployment_id}/v1/chat/completions.

    curl -X POST https://api.auxen.ai/v1/$DEP/chat \
      -H "Authorization: Bearer $DEPKEY" \
      -H "Content-Type: application/json" \
      -d '{"message":"Summarize the moon landing in one sentence."}'
  4. 4. Handle the response

    Auxen-native shape returns {message, usage, response_time_ms}. OpenAI shape returns the standard chat.completion envelope.

    # {"success":true,"data":{"message":"...","usage":{...},"response_time_ms":1247}}
  5. 5. Delete when done

    Billing stops immediately and the deployment's data is erased. Prefer pause (POST /v1/deployments/{id}/pause) if you'll need it again.

    curl -X DELETE -H "Authorization: Bearer YOUR_KEY" \
      https://api.auxen.ai/v1/deployments/$DEP

Pay-as-you-go, by the minute

One billing model. Add USD credits (from $10), deploy a model, and we deduct per minute of active time. Pause or delete and the meter stops. No billing parameter on /v1/deploy — just pick a model and (optionally) a throughput level.

Private deployment

Single-tenant. Every tier.

  • · Fast $0.15/hr · Balanced $0.20/hr · Powerful $0.65/hr · Maximum $2.25/hr (Standard)
  • · Throughput Standard / Double / Quad / Max (1.0× / 1.9× / 3.8× / 7.5× the Standard rate)
  • · More throughput = more simultaneous requests, same answer quality
  • · Pass "throughput": "quad" on deploy or call /throughput later
Best for: production endpoints, persistent agents, anything that needs isolation or steady volume.
Shared option

$0.05/hr. Fast tier only.

  • · Multi-tenant — the one exception to single-tenant isolation
  • · Standard throughput only
  • · Cheapest entry point — breakeven vs a private Fast deployment at ~11 active hours/month
  • · Chosen in the dashboard — /v1/deploy always creates a private deployment
Best for: low-volume internal agents and experiments with no isolation requirement.

Prices are under review and may change; live rates are always on the pricing page.

MCP and agent frameworks

Auxen exposes a Model Context Protocol server at https://api.auxen.ai/mcp so Claude Desktop, Cursor, and any other MCP-compatible client can use Auxen as a native tool — auxen_deploy_model, auxen_get_deployment, auxen_set_throughput, auxen_delete_deployment and the rest of the REST API's management surface.

Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json)
{
  "mcpServers": {
    "auxen": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://api.auxen.ai/mcp",
        "--header",
        "Authorization: Bearer auxen_live_xxx"
      ]
    }
  }
}

Uses the mcp-remote stdio-bridge proxy (auto-installed on first launch) to connect Claude Desktop to Auxen's remote HTTP MCP server. Fully quit and relaunch Claude Desktop to load the change.

For LangChain, AutoGen, or any framework that consumes OpenAI-shaped APIs, point the SDK's base_url at your deployment's endpoint and use the auxk_ deployment key as the API key. See the OpenAI compatibility section below.

Already using OpenAI? Switch in one line.

Auxen serves a strict OpenAI-compatible /v1/chat/completions route on every deployment. Streaming, tool calls, and standard token-usage envelopes all work the way OpenAI clients expect.

Before — OpenAI
from openai import OpenAI

client = OpenAI(
  base_url="https://api.openai.com/v1",
  api_key="sk-..."
)

resp = client.chat.completions.create(
  model="<your-frontier-model>",
  messages=[{"role":"user","content":"Hi"}]
)
After — Auxen
from openai import OpenAI

client = OpenAI(
  base_url="https://api.auxen.ai/v1/inst_xxx/v1",
  api_key="auxk_..."
)

resp = client.chat.completions.create(
  model="auxen",  # ignored
  messages=[{"role":"user","content":"Hi"}]
)

The model parameter is ignored — the model is determined by which deployment you're calling. Pass anything; we keep it in the response for clients that introspect.

Step-by-step reasoning is off by default for faster answers. Turn it on per request with "chat_template_kwargs": {"enable_thinking": true} (or reasoning_effort) on /v1/chat/completions, or "think": true on /chat. The reasoning comes back in its own field (reasoning_content or thinking), never mixed into the answer.

Errors and rate limits

Every error returns a stable code you can branch on, plus a human message and a docs link. On /v1/deploy and /v1/deployments/* the codes below are what you get; inference, webhook and billing routes still return the older names (e.g. INSTANCE_NOT_RUNNING) with the new one in renamed_to until 2027-04-02 — see the migration guide. Rate limit: 1,000 requests/minute per key. On 429s, read the Retry-After header.

CodeHTTPMeaning
API_KEY_REQUIRED401No `Authorization: Bearer …` header.
INVALID_API_KEY401Key revoked, deleted, or wrong environment.
INSUFFICIENT_CREDITS402USD credit balance is too low to start the deployment.
RATE_LIMIT_EXCEEDED429Over 1,000 requests/min. Read `Retry-After`.
MODEL_NOT_FOUND404Model id doesn't exist or is inactive.
DEPLOYMENT_NOT_FOUND404Deployment id not yours, or already deleted.
DEPLOYMENT_NOT_READY409Deployment is not `ready` yet — poll status first.
DEPLOYMENT_LIMIT_EXCEEDED429Too many deployments being created at once. Wait a moment and retry.
MAX_DEPLOYMENTS_REACHED409Your account's deployment limit has been reached.
INVALID_BILLING_MODE400`billing` parameter is no longer supported — Auxen is Pay-As-You-Go only.
INVALID_MODEL400Unknown or inactive model id.
INVALID_REQUEST400Malformed body — e.g. a `throughput` other than standard, double, quad, max (or 1, 2, 4, 8), or `/throughput` without `confirm: true`.
MISSING_REQUIRED_FIELD400A required field is missing or invalid — e.g. no `model` on deploy. An invalid `throughput` on `/v1/deploy` also returns this code.
DEPLOYMENT_FAILED502The deploy didn't complete. Safe to retry with backoff.

Build agents on a model that's yours alone.

Your private model, your endpoint, per-minute pricing — and an API surface designed for programmatic use from day one.