Skip to main content

Fast track evaluation

Evaluate Tetrate Agent Router on the Fully Managed tier without standing up any infrastructure. Sign in, route your own AI traffic through the gateway, and read back exactly what it costs. First routed request in about 15 minutes after initial onboarding; the full track, including a small team, in an afternoon.

What this evaluation covers​

Tetrate Agent Router is an AI gateway. It sits between the applications and agents that call large language models and the providers that serve them (OpenAI, Anthropic, and others), so that routing, credentials, cost, and policy are managed in one place rather than scattered across every application and developer laptop. The gateway exposes a single OpenAI-compatible endpoint, records every request, and attributes usage and cost back to the key that made it.

The Fully Managed tier is the fastest way to see that in action. Tetrate hosts the management plane, where configuration, identity, and policy live, and also runs the data plane, the gateway that carries the traffic. Nothing is installed locally, so the evaluation starts at first sign-in rather than after an infrastructure project.

The evaluation is built around the idea that results are only convincing on real traffic. Rather than a synthetic demo, the fast track routes work that already happens, a personal subscription or a working coding agent, through the gateway in passthrough mode. Passthrough means the provider continues to bill exactly as before; the gateway observes and measures without changing how the traffic is charged. Nothing is locked in, and the evaluation can be stopped at any point without unwinding anything.

By the end, the environment produces:

  • Real traffic flowing through the gateway, billed exactly as before (passthrough mode).
  • A cost and token breakdown per request, model, and key, with a monthly projection.
  • A budget with a live meter, and multiple teammates routing through the same gateway.

The result is the raw material for a rollout decision: what current AI usage actually costs, where it goes, and how it compares across a team.

Before you begin​

The fast track assumes the following are on hand:

  • The Admin Dashboard URL Tetrate provided for the evaluation tenant.
  • A provider API key already in use, for example an OpenAI or Anthropic key, so real traffic can run in passthrough mode.
  • An identity provider. An Auth0 account works well for an evaluation and takes minutes to set up; corporate IdP admin access can be used instead where it is available and approved. Learn how to set up Auth0 here.
  • A terminal or HTTP client (curl, Python, or Postman) for the first request.

Two applications appear throughout, and it helps to keep them distinct:

  • The Admin Dashboard is the operator view. Onboarding, identity, providers, models, and Agent Router settings are configured here.
  • The Console is the developer view. API keys, the proxy endpoint, request logs, usage, and budgets live here.

Getting information​

Each step is accompanied by links to relevant parts of the documentation, providing background information and details on the concerning step.

Step 1: sign in and onboard​

Access is the first thing the evaluation establishes, because every later action happens under a real signed-in identity. The first sign-in launches a one-time onboarding wizard that configures the organization: single sign-on, at least one provider, and the models to expose.

Single sign-on is configured up front for two reasons. It puts the evaluation on the same footing as a real deployment from the start, and it turns teammate onboarding] later in the fast track into a single shared link with no separate account administration. Auth0 is recommended for an evaluation because it stands up an identity provider in minutes without waiting on corporate IT. The configuration is identical to a corporate IdP, so nothing about the evaluation changes if the tenant later moves to permanent corporate SSO.

Prepare work Open the Admin Dashboard URL Tetrate provided. The first sign-in launches the onboarding] wizard. For an evaluation, sign users in with Auth0 as a temporary identity provider so you do not wait on corporate IdP admin access.

About SSO

Have corporate IdP admin access and approval to use it? Skip Auth0. Instead, in the wizard's Configure SSO step, register the displayed Redirect URI in your IdP and paste back the issuer, client ID, and client secret. Everything after onboarding] is identical.

  1. In the wizard's Configure SSO step, click IdP setup guide and copy the Redirect URI. It looks like https://auth.<your-tenant>.tetrate.ai/api/auth/sso/callback/corporate.
  2. At auth0.com, sign up and create a tenant. Go to Applications → Create Application → Regular Web Application. From its Settings, copy the Domain, Client ID, and Client Secret.
  3. Still in the Auth0 app settings, set Allowed Callback URLs to the Redirect URI from step 1, and Allowed Web Origins to your three tenant hostnames (https://auth.<tenant>.tetrate.ai, https://dashboard.<tenant>.tetrate.ai, https://router.<tenant>.tetrate.ai).
  4. In Auth0, go to User Management → Users → Create User with an email you control. This email must be an admin in the next step.
  5. Back in the wizard's Configure SSO step, fill in: Issuer https://<your-domain>/ (with the trailing slash), Client ID, Client Secret, Scopes openid profile email, Admin emails set to your Auth0 user's email, and Attribute mapping email. Click Configure.
  6. Continue the wizard: connect one provider (for example OpenAI or Anthropic) with its API key, then select models. Skip the service-account step; Tetrate runs the data plane. Click Complete setup.
  7. Sign out, then sign back in with SSO as your Auth0 user.

You should see: the Admin Dashboard loads under SSO and shows the providers and models you configured.

Relevant resources

Step 2: route your first request​

Before any real traffic runs, a single request confirms the path end to end. Two things are created here. The proxy endpoint is the OpenAI-compatible URL that fronts every configured provider; applications point at it instead of at a provider directly. The API key is the credential a client presents to the gateway, and it is also the unit that request logs, usage, and budgets attribute to, so it is worth naming keys meaningfully.

Because the endpoint is OpenAI-compatible, most existing code and SDKs work by changing only the base URL and the key. The curl and Python examples below are the same request expressed two ways.

  1. Open the Console (https://router.<your-tenant>.tetrate.ai). Go to Settings → API Keys → Add API Key, name it, and copy the value. It is shown only once.
  2. Note your proxy endpoint URL on the Console Dashboard. It ends in /v1, for example https://proxy.<your-tenant>.tetrate.ai/v1.
  3. Send a request. Replace YOUR_PROXY_URL and YOUR_API_KEY; gpt-4o can be any model in your catalog.
curl YOUR_PROXY_URL/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "messages": [{"role": "user", "content": "Hello, world!"}]
  }'
from openai import OpenAI

client = OpenAI(base_url="YOUR_PROXY_URL", api_key="YOUR_API_KEY")
resp = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello, world!"}],
)
print(resp.choices[0].message.content)

You should see: a completion, and the request in Monitoring → Request Logs with the model, token counts, cost, and latency.

Relevant resources

Step 3: put real traffic through it​

The synthetic request in Step 2 proves the plumbing; this step makes the evaluation convincing. Connecting credentials that are already paid for and routing them in passthrough mod means the gateway forwards each request using those provider credentials, and the provider bills them exactly as before. No markup is added and no billing path changes: the gateway measures the traffic rather than intercepting the charge. This is what keeps the stakes low and the numbers real.

Adding credentials is called Bring Your Own Key (BYOK). Pointing a coding agent at the gateway is the simplest way to generate representative traffic, because the agent produces the same mix of requests it always would, now visible and attributable to a single key.

  1. In the Console, go to Settings → Bring Your Own Key and add credentials for a provider you already use (for example your Anthropic or OpenAI key). Credentials are encrypted at rest and never returned.
  2. Point one coding agent at the gateway. It needs two values: the base URL and your gateway API key.
# Claude Code (the base URL is the proxy host, without the /v1 suffix)
export ANTHROPIC_BASE_URL=https://proxy.<your-tenant>.tetrate.ai
export ANTHROPIC_API_KEY=YOUR_API_KEY

Cursor and any OpenAI-compatible client take the same two values in their settings, using the full proxy endpoint that ends in /v1.

  1. Run a real task with the agent.

You should see: the agent's requests in Request Logs, attributable to your key.

Relevant resources

Step 4: see what it costs​

With real traffic flowing, the gateway can answer the question the evaluation exists to answer: what does this usage cost, and where does it go. Two views drive this. Request Logs shows a single request in detail, and Usage aggregates across a time range and breaks totals down by model and key.

The shadow bill is the headline number. It is what the routed traffic would cost at API list prices, projected to a month, which makes it directly comparable to a subscription or a direct-provider invoice. Alongside it, a few efficiency signals explain the cost: the input-to-output token split shows where the tokens go, and the cached-request share shows how much repeat work is served cheaply. Picking one number to watch turns the evaluation into a baseline that later changes can be measured against.

  1. In Monitoring → Request Logs, click a row to read input and output tokens, cost, latency (including time to first token), and the resolved model and provider.
  2. In Monitoring → Usage, read totals and breakdowns by model and key over a time range.
  3. Build the shadow bill: filter Usage to your passthrough key, read Total Spend at API list prices, and project it to a month (multiply a representative day by working days, or a week by about 4.3).
  4. Pick one efficiency number to watch, such as the input-to-output token split or the cached-request share, from the same views.

You should see: a per-request cost breakdown and a monthly projection with a real number on it, for example "this traffic is worth about $X per month."

Relevant resources

Step 5: set a budget​

Visibility becomes control once a budget is attached to the traffic. A budget sets a monthly limit on a key or a team and tracks spend against it in real time. Budgets run in one of two modes: warn mode raises alerts as the limit approaches but lets traffic continue, while block mode stops requests at the cap. Warn mode is the right choice during an evaluation, because it demonstrates the mechanism without interrupting the real work being measured.

  1. Create a budget scoped to your key or team, with a monthly limit.
  2. Start it in warn mode so it alerts without blocking traffic during the evaluation.

You should see: a budget meter showing used, remaining, and days left after the day's traffic.

Relevant resources

Step 6: bring in teammates​

A single user proves the mechanism; a small group turns it into decision material. Cost and usage patterns only become comparable when there is more than one person to compare, so this step repeats the personal setup for a handful of the heaviest AI users on the team. Those users produce the most representative spread, and the SSO configured in Step 1 makes onboarding them a matter of a shared link. The payoff is team-level attribution: spend broken down by team, model, and application, which is the evidence a rollout decision rests on.

  1. Invite the heaviest AI users on the team. On the Auth0 path, create each teammate in Auth0 → User Management → Users → Create User, share the Console URL, and have them sign in with SSO. Each appears in the Admin Dashboard Users list after their first login.
  2. Each teammate connects their own provider credentials in passthrough (Step 3).
  3. Give each team a budget sized from the numbers in Step 4.

You should see: spend comparable across teammates by model and app, with each team's meter drawing down.

Relevant resources

Go deeper (optional)​

The fast track leaves behind a working environment and a first set of numbers. The following pages build on it: