Unboxing the Machine: What the First Session Demands
A brand-new machine is the cleanest moment to decide how Claude Code will talk to its models, because nothing is inherited from a previous setup. Before the first prompt goes out, four things need to exist: a working runtime, a copy of the CLI, an authentication path, and a clear picture of what each request will cost you. Miss one of them and the first session turns into a debugging exercise instead of a working lap.
The checklist is the same whichever route you choose. Get the toolchain installed, hand over credentials, point the client at an endpoint, then send one small request that touches a real file in a throwaway repository. Only after that lap is green should you open your actual project.
- Runtime and CLI installed and confirmed from a fresh shell.
- Credentials stored in environment variables, never in a tracked file.
- Endpoint set to the host your route expects.
- Smoke test run against a scratch repository with a disposable file.
- Cost surface understood before you load a large codebase.
There is no legacy configuration to untangle, which is the gift of a fresh machine. The risk is that a lazy default sticks around for months. So take the same first session down two routes, compare what each one asks of you, and then commit.
Direct Key Route: Straightforward Until It Spreads
The direct key route is the one most people reach for first. You create an account with a model provider, generate a key, export it as an environment variable, and point the CLI at that provider's own endpoint. The first session works, and the mental model is easy: one key, one model family, one place to look when something breaks.
The trade-offs arrive later, usually the day a second model family is genuinely useful. A heavier planning pass might want Claude Opus 5.5 while quick edits are happy with Claude Haiku 4.5, and those two habits do not fit comfortably behind a single provider key. The repeatable version of that switch is a second account, a second key, a second environment variable, and a client configuration that remembers which endpoint answers which request.
On a laptop that moves between projects, that becomes a small matrix of keys to rotate, revoke, and keep out of version control. It is manageable, but it is maintenance work that has nothing to do with your code.
Cost visibility splits the same way. Each provider shows its own usage page, so the question of what a long refactor session actually consumed is answered only by adding up several dashboards. For one model family that is fine. For a working mix it becomes a chore you perform after the fact, which is exactly when it is least useful.
For a first session on a fresh machine, the direct route is a perfectly respectable way to prove the toolchain works. Just price in what it asks of you the moment your needs spread past a single family.
Relay Route: One Host Entry for Every Client
The relay route wires the same clients to a single host. With SwiftRelay, Claude Code and Gemini CLI take the bare host, https://api.fastapirelay.com, while any OpenAI-compatible SDK adds /v1 to the end of it. That one entry is what covers Claude, GPT, Gemini, DeepSeek, Kimi, GLM, Qwen, Grok and the other families behind the same door.
From the outside the workflow barely changes. You authenticate once, point the client at the host, and run the same green-light request against the scratch repository. The difference shows up on the second and third day, when you want a different model for a different job and the answer is a model name rather than a new account.
Billing is per token and pay as you go, so the first session costs exactly what the first session consumes. On a brand-new machine that matters, because the early sessions are experimental: you are trying a config, throwing it away, and trying another one. New accounts also receive a small gift credit, which is a convenient way to run the throwaway lap before you decide on a working setup.
SwiftRelay works with Claude Code, Codex, Gemini CLI and any OpenAI-compatible SDK, so the endpoint entry you write today survives the next tool you pick up. Inviting friends earns 14% of their top-ups, which is a small bonus on top of a route you were going to use anyway.
The Test Lap: Same Session, Two Configurations
Run the comparison yourself rather than taking it on faith. Set up one shell with a direct provider key and one shell pointed at the relay host, then give both the same three tasks in the same scratch repository.
- Ask for a short explanation of a file you just wrote, which is a light, disposable request.
- Ask for a refactor across three files, which exercises tool use and multi-step edits.
- Ask for a second opinion on the same diff from a different model family, which is the request that breaks single-family setups.
The first two tasks behave much the same on both routes, and that is the honest part of the comparison. The third task is where the paths separate. On the direct route it means another key and another endpoint change before the request can be sent. On the relay route it is a model name in the same client, so the second opinion happens while the diff is still in your head.
Notice also where you go to answer a cost question. On one route you reconstruct it from several provider pages. On the other you are reading one per-token record tied to the session you just ran. On a fresh machine, where every session is still teaching you what your workflow costs, that single record is worth more than it looks.
The Recommendation: Wire the Relay First
For a brand-new machine, set up the relay first and use it for the whole first week. The reasoning is simple: the relay costs you nothing extra in workflow, it removes the key matrix before that matrix has a chance to form, and it keeps every model family one name away instead of one account away. Start a session with Claude Sonnet 5.5 for the heavy reasoning, drop to a lighter model for mechanical edits, and reach across to DeepSeek V4 Flash when you want a different style of answer, all inside one configured client.
Keep the direct key route as a fallback rather than a default. If you later settle into a single model family for a long stretch, moving to its native endpoint is a five-minute change, and you will make it with real usage data behind you instead of a guess.
Here is the practical order of operations. Install the CLI, point it at https://api.fastapirelay.com with the bare host, run the scratch-repository lap, then open your real project only once the smoke test is green. Sign up for SwiftRelay to get the gift credit and run that first lap on the house.
That is the whole pit stop. One host entry, one credential, one per-token record, and a setup that still fits when your work spreads across model families six months from now. The fresh machine gives you a clean slate; wiring it this way keeps the slate clean.