How to set up a fast, low-cost Windows AI assistant with GPT-5.6 Luna

Most of what you ask an assistant is small

Think about what you actually asked an assistant this week, in between doing something else in Word, Outlook, a browser, an IDE, Photoshop, Premiere or a spreadsheet. Explain this error. Rewrite this so it sounds less blunt. Summarize this page. What does this formula do? Give me three better versions of that sentence. Hardly any of it was hard.

Those requests share a shape: short input, short output, and no hidden structure to work through. Sending them to a large reasoning model gives you the same answer, later, for several times the price. The waiting is the part you notice immediately. The cost is the part you notice at the end of the month.

So the interesting question is not which model is best. It is which model belongs in the everyday slot, and whether it can be cheap and quick enough that you stop thinking about either. GPT-5.6 Luna with reasoning turned off is a good answer to that question, and paired with a docked assistant it makes a pay-as-you-go Windows setup that costs a fraction of a monthly plan.

Why GPT-5.6 Luna suits this slot

OpenAI positions Luna for cost-sensitive, high-volume workloads, which is a fair description of an assistant you summon twenty times a day. It is by a wide margin the cheapest model in the GPT-5.6 family, and it accepts a reasoning effort of none, which is the setting this whole configuration is built around.

What that costs in practice

Prices per million tokens are hard to picture, so here is one worked example. Treat it as an illustration rather than a quote: your real cost depends on how long your prompt is, how much conversation you are carrying with it, and how long an answer you asked for.

input     2,000 x 0.20 / 1,000,000  =  $0.0004
output      500 x 1.20 / 1,000,000  =  $0.0006
                                       ---------
total                                    $0.0010

A tenth of a cent. At that size five dollars represents thousands of interactions of roughly that shape, which is why people who set this up tend to stop checking the balance after the first month.

Read that as an order of magnitude and not a rate card, because three ordinary things push a real interaction above it:

Conversation context

Every turn re-sends the whole thread. Turn twenty is paying to re-read nineteen turns of history, so a question asked in a long-running conversation costs considerably more than the same question in a fresh one.

Attachments and folder excerpts

A document or a set of retrieved passages is input on every later turn of that thread, not only the turn you attached it to.

Long answers

Output is six times the price of input here, so an unbounded essay costs more than the question that produced it.

None of that is expensive on a model priced like this. It is the difference between a tenth of a cent and a few tenths of a cent. The habits that keep it there are in reducing your AI API costs, and they are worth having anyway, because most of them improve the answers as well.

Step one: an OpenAI account and an API key

ChatGPT and the OpenAI API are both OpenAI products, and they are billed separately. A ChatGPT subscription includes no API credit, and an API balance does not pay for ChatGPT. What you want here is the developer platform, which sits behind the same sign-in if you already have an account.

1. Sign in to the OpenAI platformUse an account you will still have access to in a year, because it is the account that owns the billing.
2. Create a secret keyGo to platform.openai.com/api-keys and create one. Copy it immediately: the full key is shown once and never again.
3. Name the key for where it will liveSomething like sidenote-desktop. When you later want to revoke one key without disturbing anything else, the name is what tells you which one to revoke.
4. Set a spending limit while you are in thereDo it now rather than later. A cap in the OpenAI dashboard is the only authoritative limit, because it is the only one that sees every application using that key.

Step two: a small prepaid balance

API usage runs on prepaid credit rather than an invoice at the end of the month. You add an amount, requests draw it down, and when it is empty requests start failing instead of quietly continuing to charge you. For this kind of setup that is the right failure mode.

The minimum purchase is five dollars, and five dollars is the right place to start. Not because more would be reckless, but because you have no idea yet what your own usage looks like, and one month of real use will tell you more than any estimate on this page.

Purchased credits expire

OpenAI states that prepaid API credits expire one year after purchase and are non-refundable, so buy what you expect to use rather than a stockpile. The current terms are on OpenAI's prepaid billing page.

Nothing renews

This is pay-as-you-go consumption, not a subscription. Two quiet months cost nothing, which is the real difference from a fixed monthly plan and the reason a light user comes out so far ahead on it.

How long five dollars lasts is entirely a function of how you use it, so we are not going to promise you a number of months. On a model priced like Luna, someone asking a couple of dozen short questions a day is working in fractions of a cent per question and will not come close to finishing it quickly. Someone carrying a hundred-page PDF through a thread they never restart will get through it faster. Record your prices in the application, look at the ledger after a fortnight, and you will have a real answer instead of a guess.

Step three: the profile in SideNote Pro

This half takes about two minutes. Open Settings, then AI providers, add a profile, and choose OpenAI from the Provider list. The endpoint arrives with that choice, so the key and the model are the only values you supply.

Settings › AI providers

Provider

Choosing OpenAI fills in the endpoint and saves you typing it. The field underneath stays editable, which is what lets the same profile point at a company gateway or a proxy instead.

Profile name

Whatever you will recognise in the composer picker. Name it for the job rather than the model: OpenAI Fast survives swapping the model underneath it, and GPT-5.6 Luna becomes a small lie the first time you edit it.

Model

gpt-5.6-luna, either typed in or chosen from the picker after Test & Load models. Model IDs are case-sensitive and worth copying rather than remembering.

Context window

Auto. Luna's window is very large, and there is no reason to constrain it by hand for this kind of work.

Reasoning effort: None, deliberately

None sends reasoning_effort: none, and Luna is one of the models that accepts it. The model answers directly instead of generating hidden reasoning tokens first.

That is not a downgrade for this profile, it is the purpose of it. Reasoning tokens cost time before the first visible word appears, and they are billed as output, which is the expensive side. On rewrite this sentence or what does this error mean, they buy nothing at all, because there is no chain of inference to run. Turning them off is what makes a request that was already cheap feel immediate as well. Reasoning effort sets out exactly what each setting sends.

Settings › AI providers › Model pricing

Then send something real before you trust it. Test & Load models confirms the key reaches OpenAI and fills the model picker with what your account can use. After that, highlight a sentence anywhere in Windows and press Ctrl+Shift+E. If the answer streams back, you are finished. Using an OpenAI API key is the longer version of this walkthrough, with the troubleshooting table for when it does not.

Keep it alongside a deeper profile

A profile is a combination of endpoint, model and settings rather than a separate account, so there is no reason to ration them. Both of these can sit on the same OpenAI key:

Settings › AI providers

Model choice becomes task-specific rather than one expensive configuration answering everything, and switching is a click in the composer rather than a trip back into Settings. That difference is what turns a good intention into a habit.

What a fast profile is actually good for

Here is the honest list. These are requests where an answer appearing almost immediately is worth more than a more thoroughly considered one arriving later, and between them they cover most of what a docked assistant gets asked:

• Rewrite this email so it sounds clearer.
• Explain this error message.
• Summarize the selected text in three bullets.
• Make this prompt clearer.
• Give me three better versions of this sentence.
• What does this Excel formula do?
• Explain this paragraph in simple language.
• Turn these notes into a short reply.
• What is wrong with this command?

What they have in common is that a knowledgeable colleague would answer any of them without pausing to think. There is nothing to work through, so there is nothing for reasoning to do, and a single fast pass produces the same answer.

The workflow this enables is worth naming, because it is not the same as keeping a chat tab open. Call it blitz answering: a lot of small questions, asked in the gaps, none of them individually worth interrupting your work for. Nobody switches applications, waits, reads and switches back to find out what a shell flag does. Plenty of people will press a shortcut for it without leaving the window they are already in. The volume of those questions goes up once answers arrive that quickly, which is precisely why a cheap model belongs behind them.

We are deliberately not printing a response time. Latency depends on your connection, the size of your prompt and whatever OpenAI's service is doing at that moment. What can be said is that removing reasoning removes the largest component of the wait that you control. See getting faster AI responses for the rest of them.

Where this profile is the wrong choice

A budget configuration fails in one specific way: you keep using it on the one task it is bad at, and the answer is wrong in a way that sounds fine. So it is worth being blunt about the edges.

Send somewhere else anything whose answer depends on connecting several things correctly:

• Debugging from logs, a stack trace and code, where the cause is an interaction rather than a line.
• Architecture and design decisions, where the failure modes only appear when components meet.
• Long comparisons across two documents, hunting the contradiction nobody noticed.
• Planning exercises with real constraints, where a plausible-sounding wrong answer is readily available.
• Anything high-stakes enough that being confidently wrong costs more than the extra wait would have.

For those, switch to the deeper profile or raise reasoning effort. When to use high reasoning effort has a single question that separates the two kinds of problem reliably, and setting up a model for each kind of task covers the profile arrangement that makes switching trivial. The principle underneath both is the one running through this whole section: use the model that fits the task.

Why bringing your own key changes the arithmetic

None of this works if the software bundles the model. It works because nothing in the path does, so every decision that determines the bill is yours:

The provider

OpenAI in this example, but the same profile shape points at Anthropic, Gemini, DeepSeek, or a local runtime on your own machine.

The model

Luna here. Changing it when something cheaper or better arrives is one field.

The reasoning level

The setting that decides how much of the bill is spent thinking before answering.

The bill

You pay OpenAI directly for what you used. There is no bundled token allowance, because there are no tokens to bundle.

That last point deserves precision, because no subscription is easily misread as free. It is not free. You are paying OpenAI for API consumption at their published rate, and if you use the assistant heavily you will pay more than someone who does not. What you are not paying is a fixed amount every month that arrives whether you used it or not. What BYOK means covers the architecture properly.

Cheap models are what make that arrangement genuinely comfortable rather than merely principled. When a request costs a fraction of a cent, metered billing stops being something you monitor and becomes something you forget about, which is the relationship you had with a subscription, without the subscription.

The setup, in one block

Then a second profile on a stronger model with reasoning raised, for the problems that need it, and Make default on the fast one so it is what a new conversation opens on.

That is the whole configuration. About ten minutes including the account, and the ongoing cost is whatever you actually use.

Worth the ten minutes

The assumption worth dropping is that a useful desktop assistant requires another expensive monthly plan. For small everyday work it does not. GPT-5.6 Luna with reasoning disabled makes the economics small enough to stop thinking about, and its speed suits an assistant designed to sit beside your work rather than one you go and visit.

Keep a stronger profile for the hard problems, and let the fast one take everything else. That is not a compromise. For most of what you ask in a day, it is simply the right tool.