> ## Documentation Index
> Fetch the complete documentation index at: https://docs.verlon.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Bring Your Own Models

> Register fine-tunes and self-hosted endpoints as first-class models you can route to through Verlon AI

## Overview

An **owned model** is a model *you* serve: a fine-tune you deployed on Fireworks, or your own OpenAI-compatible inference server. You register it once, and it becomes routable anywhere Verlon takes a model — gates, fallback chains, the model picker — with the same observability, cost tracking, and hot-swapping as a catalog model.

<Note>
  **Owned models are not [BYOK](/platform/byok).** BYOK means *your keys, our
  catalog* — your provider account serving the public models Verlon already
  knows about. Owned models mean *your model*: something the catalog has never
  heard of, registered with its own credential. Rotating a BYOK channel key
  never affects an owned model, and deleting an owned model never touches your
  catalog access.
</Note>

## Where a model can live

| Host                | What it's for                                                                                               | Credential                                       |
| ------------------- | ----------------------------------------------------------------------------------------------------------- | ------------------------------------------------ |
| **Fireworks**       | A fine-tune or custom deployment on your Fireworks account                                                  | Required — a Fireworks API key                   |
| **Self-hosted URL** | Any OpenAI-compatible server you operate — vLLM, SGLang, LM Studio, llama.cpp, a dedicated cloud deployment | Optional — many self-hosted servers have no auth |

Together AI, Bedrock Custom Model Import, and SageMaker are planned; registering them is refused today rather than accepted and mis-billed.

Owned models are **chat models** for now. Embeddings arrive alongside embeddings support for the Fireworks channel; image and audio wait for their own pricing units.

## Registering a model

From the dashboard, go to **Models → Your Models → Your own models → Register a model**. The form asks four questions.

<Steps>
  <Step title="Name">
    A human name. Verlon derives the routing reference from it — "Support summarizer tune" becomes `custom:support-summarizer-tune`. The reference is permanent; renaming means registering again.
  </Step>

  <Step title="Where it lives">
    Fireworks, or a self-hosted URL. For Fireworks, the **model id** is the fully-qualified id from your account, like `accounts/your-org/models/your-tune-v1`. For a self-hosted endpoint, it's whatever model name your server exposes.
  </Step>

  <Step title="Credential">
    Stored encrypted and scoped to this registration only — never shared with your channel keys, and never returned by the API. Self-hosted endpoints without auth can leave it empty.
  </Step>

  <Step title="Cost per 1M tokens">
    What this model costs *you*. See [Declaring cost](#declaring-cost) below.
  </Step>
</Steps>

Verlon probes the endpoint when you save, but **saves either way** — a self-hosted box that's asleep is registered and marked amber until a probe succeeds, rather than blocking you.

## Routing to an owned model

Reference it as `custom:<slug>` anywhere a model id is expected:

```json theme={null}
{
  "name": "support-summarizer",
  "taskType": "chat",
  "model": "custom:support-summarizer-tune"
}
```

It appears in the model picker under **Your own models** — listed first, since a model you went to the trouble of deploying is usually the one you're looking for. It works in fallback chains alongside catalog models, and its traffic shows up in logs and the catalog's usage columns like anything else.

References resolve **per user**. `custom:support-tune` means your registration and nobody else's.

## Declaring cost

Verlon records a cost for every request — it feeds your logs, analytics, spending limits, and the model comparison view. The catalog knows what public models cost; it cannot know what *your* deployment costs you. So you declare it.

* **Input** and **output** rates, in USD per 1M tokens.
* **Cached input** is optional. Left empty, cached tokens bill at the full input rate — which can only *overstate* your real bill, never hide spend.
* **Reasoning tokens need no field.** OpenAI-compatible servers report them inside the completion count, so your output rate already covers them.

**Leave every rate empty and the model records `$0`,** shown as `owned · $0`. For a server you already pay for by the hour, zero per-token cost is the honest answer — not a pricing error. If you'd rather see your infrastructure amortized per token, declare a rate that reflects it.

<Warning>
  **Pricing changes apply to future requests only.** Every request's cost is
  computed and stored when it runs, so editing rates never rewrites history. If
  a pricing mistake has already distorted your recorded spend, contact support
  and we'll correct the affected data.
</Warning>

## Self-hosted endpoints must be reachable from the internet

Verlon calls your endpoint from our servers. That has consequences worth knowing before you register one:

* **`localhost` will not work.** Not `http://localhost:11434/v1`, not a private LAN address, not a VPN-only host — our servers cannot see them. Expose the server through a tunnel (Cloudflare Tunnel, ngrok, Tailscale Funnel) or put it behind a public hostname.
* **Private and reserved addresses are refused** at registration, along with cloud metadata endpoints and URLs with credentials embedded in them.
* **Redirects are not followed**, and hostnames are re-resolved and checked at connection time — so give us the final URL.
* **Use HTTPS and an auth token** if the endpoint is public. Anything reachable by us is reachable by others.

If your endpoint is up but a probe fails, the registration still saves and shows **Unreachable**. Routing to it will fail until the box answers — the badge is telling you the truth, not blocking you.

## Managing a registration

From **Manage** on any owned model you can:

* **Edit pricing** — forward-looking, per the warning above.
* **Replace the credential** — rotating a key triggers a fresh reachability probe.
* **Delete the registration** — refused while any of your gates still routes to it. Repoint those gates first, so routing never dangles.

## What Verlon does and doesn't see

Your inference runs on your account or your hardware, on your credential. Verlon routes the request, records what it cost and how it performed, and never becomes an intermediary for your inference spend. Owned models are never added to the shared catalog — they're yours, visible only to you.