Quickstart

This page takes a freshly installed platform to a first model answer over the API and a first agent. It is written for the platform administrator who installed Olympusx AI; the steps from Deploy the model onward are the ones a tenant admin and a builder take on their own.

Before you start

Olympusx AI is installed and its checks pass. See Install overview and Verify the installation.
You can sign in as a platform administrator. See First sign-in.
The model you want is reachable: its weights are in your registry or can be imported, or a cloud provider that serves it is connected. See Model registry and External models.

1. Follow the setup checklist

Sign in at https://<your-console-host>. An empty platform opens on its setup checklist. Work through it in order; each step has a button to the page where it is done and is marked Done once the platform counts it.

Register a cluster. An operator install has already registered the cluster it runs on.
Put GPU nodes in the serving pool. Skip this on a cluster with no GPUs: models then serve on CPU nodes.
Create the first tenant. Give it a display name, a slug and a first project, and grant it capacity on the cluster: some CPU cores and memory at least, and GPUs if it will serve on them.
Seed the model catalog. Add the model from Model serving › Model registry.
Offer models as LLMaaS and Grant a model to a tenant. Granting is what lets one tenant’s keys reach a model.
Serve a model. Covered as step 2 below.
Issue an API key. Covered as step 3 below.
Publish a price book. Traffic is served without one, but it cannot be invoiced.

The full list, with what each step means, is in First sign-in.

2. Deploy the model

A tenant admin, or you as platform administrator, deploys the granted model for the tenant.

Go to Build › Models and select Deploy on the model.
In Placement, choose the project and cluster it runs in.
Follow the remaining steps. The wizard checks that the model fits the hardware and the tenant’s capacity before it lets you deploy.
Wait until the model’s status reads as serving.

A model a cloud provider serves needs no deployment: granting it is enough. Details are in Deploy a model.

3. Create an API key

Go to Govern › Keys and budgets, choose the tenant and the project.
Create a key, give it a name, and choose when it expires.
Copy the secret now. It starts with olp_ and is shown once; Olympusx AI keeps only a hash of it.

Set a budget on the key or its project if you want the gateway to stop it at a number of tokens. See Keys and budgets.

4. Make the first call

Call the gateway with the key and the model’s name exactly as the catalog shows it.

export OLYMPUS_API_KEY='olp_...'
curl -s https://<your-gateway-host>/v1/chat/completions \
  -H "Authorization: Bearer $OLYMPUS_API_KEY" \
  -H 'content-type: application/json' \
  -d '{"model":"<model-name>","messages":[{"role":"user","content":"Say hello in one sentence."}]}'

A 200 with a choices array is a working platform. To list every model the key’s tenant can call right now:

curl -s https://<your-gateway-host>/v1/models -H "Authorization: Bearer $OLYMPUS_API_KEY"

When it did not work

Answer	What it means
`401` with `missing_credentials` or `invalid_key`	The key was not sent, or was mistyped.
`403` with `model_not_granted`	The tenant is not granted this model. Grant it on the tenant’s page.
`404` with `model_not_deployed`	The tenant is granted the model, and no deployment serves it. Check its status in Build › Models.
`429` with `budget_exceeded`	A budget on the key, project or tenant is spent for the period.

Every code is listed in Errors.

5. Build a first agent

Go to Build › Agents and create an agent.
Give it a name and a description, instructions, and the model you deployed.
Add a knowledge collection or a tool if you have one. Both are optional for a first agent.
Open Preview and ask it a question. The run appears in Operate › Runs, with every step it took.

To put the agent in front of people, publish it as an assistant. See Create and edit an agent and Publish and share an assistant.

Next steps

Invite people to the tenant and give them roles.
Turn on guardrails for the tenant.
Build knowledge from your documents.
Connect an editor to the tenant’s models.