# Connect your computer and test a model

Connect a computer to your Saylek account, then confirm that a model on it can answer through Saylek. Keep sharing off for this first check. You can decide who else may use the machine afterward.

## Before you start

Use a terminal, your computer's command-line application, on the computer you want to connect. Released Saylek binaries target Linux x86_64 and Apple Silicon Macs; Windows uses the Linux build inside WSL2 x86_64.

Choose the situation that matches your machine:

| Starting point | What you need |
| --- | --- |
| Already running models | A supported runtime such as Ollama, LM Studio, llama.cpp or vLLM, running on this machine with at least one model available. |
| No runtime yet | Supported NVIDIA hardware and driver on Linux/WSL2, or an Apple Silicon Mac, plus enough memory and disk space for a model. Check the [managed-runtime requirements](/docs/start-without-a-runtime#before-you-begin) before downloading. A supported operating system alone does not establish GPU/runtime compatibility. |

Sign in to [Saylek](https://saylek.com). Installation runs a background service; serving a model uses compute and memory. The managed path may download both a model and an inference runtime. You do not need to enable sharing to use your own machine.

## 1. Connect the machine

On that machine, run:

```bash
curl -fsSL https://saylek.com/install.sh | sh -s -- --connect
```

Follow the sign-in steps. The installer links the machine to your account and can connect an existing runtime it detects. It does not download a starter model. For a new connection, sharing stays off. If you are reconnecting a machine, check its existing sharing settings rather than assuming they were reset.

To inspect the script first, download `https://saylek.com/install.sh`, read it, then run it with `--connect`.

**Check:** open [Machines](/machines) and find this computer. If it is still waiting to connect, run `saylek status` on the computer. If the daemon is stopped, follow [the startup steps](/docs/quickstart#2-check-the-daemon-is-up); if it is running but not connected, use [connection troubleshooting](/docs/troubleshooting) and the reported error before continuing.

## 2. Make one model available

Follow one of the two options below, whichever matches your machine.

### Already running a runtime

Keep the runtime running, then inspect the machine's Models section or run:

```bash
saylek models
```

If the model is missing, check the runtime's actual listening address and port. For an Ollama instance using its default local port:

```bash
saylek host engine add http://127.0.0.1:11434 --no-advertise
```

Use your runtime's actual port if different. The `--no-advertise` option connects the source without adding its models to the sharing selection. It does not withdraw models already offered; check the existing selection with `saylek host models`. If no selection is set, a machine that is sharing offers every model it serves, this runtime's included. For authentication or a different runtime, use the [existing-runtime setup](/docs/use-your-existing-runtime).

### No runtime yet

On a machine that meets the managed-runtime requirements, run:

```bash
saylek gpu wizard
```

When no model is already available to serve, the interactive wizard can offer a starter model and ask whether to download it. Review the offer before accepting. Allow time and disk space for the download; do not expect account creation or machine connection to provide a model automatically.

**Check, after either option:** the model appears in the machine's Models section and in `saylek models`. Listing is preparation; the next step tests serving.

## 3. Ask this machine for an answer

On the connected computer, run this command without a `--model` option:

```bash
saylek call "Explain what a GPU does in one sentence."
```

This uses the first model the machine serves for the local check. The first request may take longer while the model loads; the managed Linux path may also fetch and verify its runtime on first load.

**Success:** the command prints a model response. If it reports a failure, the local serving check has not passed, even if the model is listed as Ready. Inspect the error before continuing.

Now check the machine's sharing setting. For this path it should still say **Only you can use its models**. A local response confirms local serving; it does not yet confirm that an app can reach the machine through the hosted API.

## 4. Use it from your app

Follow [Get your first answer in an app](/docs/first-answer-in-an-app) to create an application key and verify a response inside the application. Your own keys can use your connected machine with sharing off.

Hosted requests pass through Saylek's servers. If another machine you can use serves the same model, that machine may answer instead. A successful hosted answer is not proof that this particular computer served it. [Privacy and egress](/docs/privacy-and-egress) explains routing and its boundaries.

## Share spare capacity

Share a machine whose main job is still your own work. Do this only after your own workflow works on it.

1. **Choose when others can use it.** On the machine's page, **Edit schedule** sets its sharing hours, or run `saylek host hours --set 18:00-08:00` on it. Hours use the machine's clock, a schedule has at most 5 periods, and they do not limit your own keys.
2. **Choose how much it takes at once.** `saylek host slots 1` sets how many requests Saylek sends the machine at once; `--clear` resets it. That number is not split between your requests and other people's. To offer only some models, use `saylek host models MODEL_ID`.
3. **Switch sharing on and invite one person.** Follow [Help someone get their first useful answer](/docs/help-others-use-ai).
4. **Run your own work while they use it.** In a time you agree, run a representative piece of your usual work on the machine while they run their task. Work your applications send to Saylek's local API on the machine is taken before waiting shared requests. When Saylek runs the model, it also stops a running shared request at its next step. With your own runtime, Saylek stops passing it shared requests, but the runtime may finish work it already has. Requests you send through the hosted API, even with your own key, are not local work and do not stop running requests. Expect your work to share the machine, and decide whether its speed stays acceptable. [Make more of one GPU](/docs/make-more-of-one-gpu) explains the details.
5. **Adjust.** Narrow the hours, lower the slots, or change which machines a person can use. To take the machine back for a while, turn off **Share from this machine**, or run `saylek host stop` and later `saylek host start`.

### Watch what your machine serves

The machine's page in Machines lists its requests, newest first, with the outcome, when, who and which model. Its activity line shows how much of the time Saylek could see the machine it was doing your own work. Use both to decide whether to share more hours or fewer.

## If a step fails

| Symptom | Next check |
| --- | --- |
| Machine does not appear | Run `saylek status`. If stopped, follow [startup steps](/docs/quickstart#2-check-the-daemon-is-up); if running, follow [connection troubleshooting](/docs/troubleshooting) for the reported error. |
| Existing runtime is unreachable | Start it and check its actual local address, port and any authentication requirement. |
| Model is listed but cannot load | Read the reported load error. Check available memory, driver/runtime support and the model file rather than assuming installation failed. |
| Only some models are offered | Run `saylek host models` to inspect the selection. Do not clear it merely to refresh: `--clear` removes the filter and can offer every model the machine serves, including future additions, when sharing is active. |
| No compatible managed runtime is available | Check the [managed-runtime requirements](/docs/start-without-a-runtime#before-you-begin) and exact error. Do not bypass signature checks or assume every GPU is supported. |

**To stop serving through Saylek:** `saylek stop` stops the Saylek daemon. An external runtime such as Ollama may continue running independently. To disconnect the machine from your account, use its **Settings → Remove from account** control. Removing the account connection and uninstalling software are separate actions; see [Command reference](/docs/cli-reference) for local cleanup.