Skip to content

Use your models from anywhere

Connect an OpenAI-compatible chat client with your Saylek API key and a model you can use. You do not need a Saylek daemon on the machine running the client.

Available models come from your own machines, from people who share with you, and, if you joined a group, from machines in that group. A model appearing in your list is not a reservation: a machine still has to be free to serve the request.

This guide uses the hosted Saylek API, the recommended RC integration path. If your client uses Anthropic Messages instead, follow Anthropic setup.

1. Create an API key

Open Applications and add an application to create its API key.

A key's secret is shown once, at creation. Save it then. If you lose it, create a new key rather than trying to recover the old one.

2. Find a model you can reach

Use a model id exactly as it appears in your current list. Do not substitute a model name from another provider. List the models available to your key:

curl https://api.saylek.com/v1/models \
  -H "Authorization: Bearer YOUR_API_KEY"

Pick a model suitable for chat and use its id as MODEL_ID below. A listed model is not a promise that it supports every client feature, input type, or tool call. Check the model's capabilities before using it for an agent or a different task.

This guide does not assign a context limit. Keep an already verified explicit client override if you have one; otherwise leave it unset.

3. Point your client at it

Most OpenAI SDKs take a base URL and a key:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.saylek.com/v1",
    api_key="YOUR_API_KEY",
)

resp = client.chat.completions.create(
    model="MODEL_ID",
    messages=[{"role": "user", "content": "hello"}],
)
print(resp.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.saylek.com/v1",
  apiKey: "YOUR_API_KEY",
});

const resp = await client.chat.completions.create({
  model: "MODEL_ID",
  messages: [{ role: "user", content: "hello" }],
});
console.log(resp.choices[0].message.content);

Most tools that accept an OpenAI base URL take the same two values. Set OPENAI_BASE_URL and OPENAI_API_KEY when a tool reads them from the environment:

export OPENAI_BASE_URL="https://api.saylek.com/v1"
export OPENAI_API_KEY="YOUR_API_KEY"

4. Confirm it works

curl https://api.saylek.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "MODEL_ID",
    "messages": [{"role": "user", "content": "hello"}]
  }'

Thinking controls

On /v1/chat/completions, four request fields are read as thinking controls: reasoning_effort, chat_template_kwargs, think and reasoning. The Anthropic dialect handles its own thinking field separately.

reasoning_effort: "none" is the one value read as an instruction. It asks for the turn without extended thinking, and Saylek carries that request to the machine serving you. What the model does with it is up to the model, and the answer does not report which way it went.

Your own reasoning_effort is forwarded untouched for any other value. It reaches the engine that serves your turn under the same name, and Saylek does not validate it, does not judge it and does not act on it. A graded effort is not a compute budget here: "high" reserves no tokens and no time.

What you sendreasoning_effortchat_template_kwargs, think, reasoning
The exact string "none"HonouredForwarded untouched
Any other string, including ""Forwarded untouchedForwarded untouched
A value that is not a string: a number, a boolean, a list, an objectForwarded untouchedForwarded untouched
The field absent, or nullNot sentNot sent

Honoured means Saylek carried an instruction to the machine serving the turn. Forwarded untouched means the engine got the field as you sent it. Not sent means you stated no preference. An explicit null still travels with your request; it just says nothing.

The three sibling fields carry no off switch: "none" in any of them is forwarded like any other value. Neither is the Responses API spelling, reasoning: {"effort": "none"}; on this path it is not a string, so it is forwarded untouched too.

No thinking field is dropped on this path. Each one reaches the engine under the name you sent it, and no value is refused, so you never lose a turn over the form of a control.

When it can answer

An eligible machine must be online, able to serve the requested model, and have capacity. If a call fails because no capacity is available, check your model list and try again when capacity returns. Adding a key does not add a machine or reserve capacity.

Hosted requests pass through Saylek and are handled by the serving machine, even when that machine is your own. A machine shared with you can also process your prompt, and so can a machine in a group you joined. Read Privacy and egress before sending anything sensitive through it. The local-only controls described there apply to the daemon, not to this hosted path: if you need a request to stay on your own machine, use the local daemon with local-only on, and check that no proxy upstream of your own would claim the model first.

Connecting a model does not add web search. Where your client and model support tool calling, use a search tool your client runs itself. A generated answer alone is not evidence that a search ran; check the client's tool results.

If you use the Anthropic Messages endpoint, requests declaring provider-run tool types such as web_search or web_fetch are refused with HTTP 400. The error names the unsupported tool type and links to the setup guidance: Web search.

The Codex CLI does not work against this endpoint. Codex speaks only OpenAI's Responses API and asks the endpoint to hold each turn of the conversation server side, then to continue from it by id on the next turn. Saylek forwards a request to a serving machine and returns the answer, so there is no stored turn for Codex to continue from and the request is refused. Other OpenAI-compatible clients on this page are unaffected: they send the whole conversation each time, which is what this endpoint expects. Tools that let you choose the wire protocol should be pointed at chat completions rather than responses.

Next steps

Last checked 2026-09-24 · read as markdown at /docs/connect-openai.md