Olympus

Hypervize picks the right model every time — so you don’t have to.

You shouldn’t need a chart of Claude vs GPT vs Grok to get a good answer. Olympus is how AI should always behave: automatic. Invisible when it’s working. Overrideable when you’re picky.

Olympus is its own foundational product — basic, obvious, free. On by default. Not a premium SKU. Not merged into any other tool. You pay the answer model’s tokens (or a free message). There is no Olympus tool fee.

Chat — we do the work

Chat Auto is on by default.

1. You talk.
2. Hypervize picks the model that fits.
3. As the chat changes, Auto keeps up.
4. You can still open the model picker anytime (that pauses Auto for this chat until you turn it back on).

You don’t configure routing. You don’t pick Claude vs GPT. You just chat.

API — send model: "auto"

You do not need extra Olympus endpoints.

Olympus is on by default. Sending a named catalog model does not run Auto — the request stays on that model.

Call completions (or Responses) with Auto when you want Hypervize to pick:

• Unpinned keys: Auto is on. model: "auto" works. Unpinned completions may also inject the olympus platform tool with your other enabled tools.
• Turn it off entirely: disable Olympus in Alexandria, or DELETE /api/tools { "tool_id": "olympus" } with your API key. Chat Auto stops; model: "auto" returns 400 olympus_not_enabled; the tool is no longer injected.
• One key only: pin that key’s tools and omit olympus (Settings → Keys, or the keys API). That key will not inject the tool and will reject model: "auto". Other keys on the account are unchanged.

A key whose tool pin excludes olympus rejects model: "auto". Leave the pin empty, or include olympus, if you want Auto on that key.

Aliases: auto · olympus · olympus-auto

export HVZ_KEY="hvz_live_…"
export HOST="https://hypervize.tech"   # or http://localhost:3000

curl -N "$HOST/api/chat/completions" \
  -H "Authorization: Bearer $HVZ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "auto",
    "messages": [
      { "role": "user", "content": "Help me debug this webhook signature check." }
    ],
    "stream": true
  }'

from openai import OpenAI

client = OpenAI(base_url="https://hypervize.tech/api", api_key="hvz_live_…")

stream = client.chat.completions.create(
    model="auto",
    messages=[{"role": "user", "content": "Help me debug this webhook signature check."}],
    stream=True,
)
for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

const res = await fetch("https://hypervize.tech/api/chat/completions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.HVZ_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "auto",
    messages: [
      { role: "user", content: "Help me debug this webhook signature check." },
    ],
    stream: false,
  }),
});
const completion = await res.json();
if (!res.ok) {
  throw new Error(completion.error?.message || completion.message || res.status);
}
console.log(completion.choices[0].message.content);
// optional: completion.hypervize?.olympus?.selected

The response model is the catalog display name that answered. A single model: "auto" call is automatic, but it is not the full Chat loop until you keep memory (below).

Auth: Authorization: Bearer hvz_live_… (same key as Elastic Inference).

Responses works the same way:

r1 = client.responses.create(model="auto", input="Summarize this thread.")
r2 = client.responses.create(
    model="auto",
    input="Now make it shorter.",
    previous_response_id=r1.id,
)

With previous_response_id, Hypervize continues the thread and Auto memory. You do not send a memory blob.

Pinned keys. On /api/chat/completions and /api/responses, a catalog pin on the key wins over model: "auto". Pin auto (or leave the pin empty) to let Olympus pick. /api/b/… always applies the key pin first — pin auto there if you want Auto on that path.

If Auto cannot pick, you still get a reply on a catalog model (your last model, or Claude Sonnet).

The first Auto call in a new thread picks from this request’s messages only. Later calls get better if you send memory back (completions) or use previous_response_id (Responses).

Response extras (optional)

You can ignore these. Official OpenAI SDKs still work for a one-shot model: "auto".

• JSON: hypervize.olympus.selected is the display name that answered.
• JSON: hypervize.olympus.prior is an opaque blob. Persist it; send it back next time (see wrapper below). Do not parse it.
• Stream: event: olympus.decision first (the pick). On completions, a later event: olympus.memory (before [DONE]) may carry a fresher prior. OpenAI clients ignore unknown events. If the model uses platform or webhook tools, you may also see event: olympus.switch once when Auto changes model mid-reply. On Responses, keep using previous_response_id — Auto memory is stored on the response, not as a second SSE event.

Keep memory on completions (wrapper)

Official SDKs will not echo hypervize.olympus. If you use completions for a multi-turn agent, persist the extras yourself:

const BASE = "https://hypervize.tech/api";

export async function autoComplete(apiKey, messages, memory = {}) {
  const res = await fetch(`${BASE}/chat/completions`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${apiKey}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "auto",
      messages,
      olympus: {
        current_model_id: memory.selected,
        prior: memory.prior,
      },
    }),
  });
  const data = await res.json();
  if (!res.ok) {
    throw new Error(data.error?.message || data.message || res.status);
  }
  return {
    text: data.choices[0].message.content,
    model: data.model,
    memory: {
      selected: data.hypervize?.olympus?.selected,
      prior: data.hypervize?.olympus?.prior,
    },
  };
}

Treat prior as opaque. On Responses, prefer previous_response_id instead of this wrapper.

Closest to Chat (API)

Chat stores memory on the conversation. The API does not, unless you do one of the following.

Prefer Responses if you can. previous_response_id is the Chat-like path: thread + Auto memory, no blob to store.

from openai import OpenAI

client = OpenAI(base_url="https://hypervize.tech/api", api_key="hvz_live_…")

r1 = client.responses.create(model="auto", input="Help me debug this webhook signature.")
r2 = client.responses.create(
    model="auto",
    input="Now write a unit test for the same function.",
    previous_response_id=r1.id,
)

Completions: use the wrapper, keep the message list, and reuse memory every turn. Use stream: false (or drain extras yourself) so prior is on the JSON body.

let messages = [];
let memory = {};

async function turn(userText) {
  messages.push({ role: "user", content: userText });
  const out = await autoComplete(process.env.HVZ_KEY, messages, memory);
  messages.push({ role: "assistant", content: out.text });
  memory = out.memory;
  return out;
}

await turn("Help me debug this webhook signature.");
await turn("Now write a unit test for the same function.");

That is the full API experience we support: same picker as Chat across turns. Mid-reply switch applies only when Hypervize is running platform or webhook tools for you. If you pass your own function tools, Auto does not take over that loop — send model: "auto" again on the next request (with memory).

Advanced

Most apps should stop at model: "auto".

Optional /api/olympus/* builder routes exist if you persist your own conversation memory or inspect a pick. They are not required to use Auto.

If you call them, treat the payloads as opaque. If a pick fails, still call completions with your last catalog model so the user gets a reply.

Billing

Send model: "auto". You pay the answer model’s tokens (or a free message, with the usual free-tier model limits). There is no extra Auto SKU on that path.

If you call the optional /api/olympus/* routes, those calls meter separately on prepaid.

An explicit Olympus tool step (for example in a Chronos recipe) is free. Chat/API Auto has no tool SKU either — you pay the answer model.

Errors

Same dual OpenAI shape as other inference routes (error.message + top-level message). See Errors.

Related

• Platform Tools
• Models
• Elastic Inference
• Code Examples
• Billing