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

What changed with GPT-6 Luna

OpenAI released GPT-6 Luna, model ID gpt-6-luna, on 22 September 2026, alongside GPT-6 Sol. OpenAI describes it as its most efficient model for focused, high-volume tasks. For anyone running a cheap everyday profile, the news is the price: both sides of the rate card are lower than on GPT-5.6 Luna, the low-cost model of the previous generation.

Input drops from $0.20 to $0.10 per million tokens, and output from $1.20 to $0.50. Output is the side that matters more for an assistant, because it is the expensive side and because reasoning tokens, when a model generates them, are billed as output. On the interaction size worked through below, the same request costs a little under half as much.

The shape of the setup does not change. Both models have the same context window and both accept a reasoning effort of none, which is the setting this configuration is built around. The GPT-5.6 Luna configuration remains the reference for that model. Everything needed for GPT-6 Luna is on this page.

Why GPT-6 Luna fits the everyday slot

Look at what gets asked of an assistant in an ordinary day. What does this error mean? Make this reply less abrupt. Summarize the page I am reading. Explain this formula. Turn these notes into three bullets. Most of it arrives in the gaps between other work in Outlook, a browser, an editor or a spreadsheet, and very little of it is hard.

Requests like these are short going in and short coming out, with nothing hidden in them to work through. A large reasoning model answers them correctly as well, but later, and for several times the price. So the useful question is not which model is best. It is which model belongs in the everyday slot, and whether it can be quick and cheap enough that you stop noticing either.

GPT-6 Luna is built for that description. OpenAI positions it for focused, high-volume tasks, which is a fair account of an assistant summoned twenty times a day, and it accepts a reasoning effort of none, so a simple request gets a direct answer rather than a round of hidden reasoning first.

What GPT-6 Luna costs in practice

A price per million tokens is hard to picture, so here is one interaction worked through. It uses the same size as the GPT-5.6 Luna example, roughly 2,000 tokens in and 500 out, so the two generations compare directly: a question with some context going in, a few paragraphs coming back.

input     2,000 x 0.10 / 1,000,000  =  $0.00020
output      500 x 0.50 / 1,000,000  =  $0.00025
                                       --------
total                                  $0.00045

That is just under a twentieth of a cent. The same request on GPT-5.6 Luna comes to $0.0010, so the newer model does the same small job for a little under half the price.

Five dollars divided by that figure is a little over eleven thousand, and it would be easy to turn that into a promise. It is not one. Real use is never eleven thousand identical, isolated requests, and several ordinary things push an actual interaction above the example:

Conversation history is resent

Every turn carries the thread so far, so a question asked twenty turns into a conversation pays to re-read the nineteen before it.

Documents and retrieved context are input

An attached file or a set of folder excerpts is sent again on every later turn of that thread, not only the turn it arrived on.

Long answers cost more

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

Very long prompts are priced differently

OpenAI bills a request with more than 272,000 input tokens at a higher rate for the whole request: twice the input and cached-input rates, and one and a half times the output rate. With Context window on Auto, SideNote Pro does not plan requests anywhere near that size, so this only matters if you deliberately configure a much larger context.

None of that turns into a large number on a model priced like this, but it does explain why two people on the same model see very different totals. Reducing your AI API costs has the habits that keep the figure small, and most of them improve the answers as well.

Step one: an OpenAI API key and a small balance

ChatGPT and the OpenAI API are separate products with separate billing. A ChatGPT subscription includes no API credit, and API credit does not pay for ChatGPT. Using GPT-6 Luna from a desktop application goes through the API, on OpenAI's developer platform, which uses the same sign-in if you already have an OpenAI account.

1. Sign in to the OpenAI platformUse an account you expect to keep, because it owns both the billing and the keys.
2. Create a secret keyAt platform.openai.com/api-keys. The full key is shown once, so copy it before closing the dialog. Name it for where it will live, such as sidenote-desktop, so you can later revoke that one key without disturbing anything else.
3. Add a small prepaid balanceAPI usage draws down prepaid credit, and when it runs out, requests fail rather than carrying on. For a personal setup that is the right way to fail. Prepaid credit has expiry and refund terms of its own, set out on OpenAI's prepaid billing page, so buy what you expect to use rather than a stockpile.
4. Set a spending limitIn the OpenAI dashboard. It is the only limit that sees every application using the key, which makes it the one that counts.

How long a balance lasts depends entirely on how you use it, so there is no number of months on this page. Record the prices in the application, as described below, and a couple of weeks of real use will tell you more than any estimate here.

Step two: GPT-6 Luna in SideNote Pro

SideNote Pro is a Windows assistant that stays docked beside your work and sends each request straight to the provider you configure, with your own key. Open Settings, then AI providers. If you already have an OpenAI profile, change its model rather than adding another. Otherwise select Add profile and choose OpenAI from the Provider list, which fills in the endpoint.

A new OpenAI profile currently starts on gpt-5.6-luna with reasoning on None, so the model is the field to change. Paste your key, select Test & Load models so the picker fills with the models your account can use, then choose gpt-6-luna from the list or type it in. Model IDs are case-sensitive, so copy rather than retype them.

Settings › AI providers

Profile name

Name it for the job rather than the model. OpenAI Fast still makes sense after the next model change, while GPT-6 Luna stops being true the moment you edit the field.

Context window

Leave it on Auto. Everyday requests come nowhere near the model's limit, and Auto keeps what SideNote Pro sends at a sensible size.

Reasoning effort: None, on purpose

None sends reasoning_effort: none, which GPT-6 Luna accepts. The model answers directly instead of generating hidden reasoning tokens first.

The alternative is not zero reasoning. OpenAI documents medium as GPT-6 Luna's default, and Provider default in SideNote Pro leaves the field out of the request, so a profile left there asks for medium reasoning every time. Reasoning tokens take time before the first visible word and are billed as output, the expensive side. On rewrite this sentence or what does this error mean they buy very little, because there is nothing to reason through.

That does not make None the better setting in general. It suits routine requests, where extra thinking adds wait and cost without changing the answer. For work that does need it, raise the effort on a separate profile, as described below. Reasoning effort explained sets out what each setting sends.

Record the prices

SideNote Pro counts tokens locally but ships no provider prices, so it cannot estimate spending until you enter them. In the Model pricing block under the profile, enter 0.1 for input and 0.5 for output, in USD per million tokens, and select Use these prices.

Prices are stored per profile and model, so gpt-6-luna starts without any even if you recorded GPT-5.6 Luna's on the same profile, and responses already recorded keep the price that applied when they were sent. The estimate uses those two rates only. It does not model OpenAI's cached-input rate or the long-prompt rate, so treat it as a guide and OpenAI's own billing as the record. Usage and cost tracking covers the rest.

Test it with something real

Highlight a sentence in any application and press Ctrl+Shift+E, the default shortcut for Explain. If an answer streams back, the profile works. If it does not, using an OpenAI API key is the longer walkthrough, including what to check when a request fails.

Keep a deeper profile beside it

A profile is a combination of endpoint, model and settings, not a separate account, so both of these can share one OpenAI key:

Settings › AI providers

Start on the fast profile and escalate when an answer is visibly shallow. Most problems that look hard turn out not to be, and you find that out in seconds. Choosing an AI model covers what belongs in the deeper slot, and a model for each kind of task covers the arrangement as a habit.

What GPT-6 Luna is good for

Requests where a quick answer is worth more than a more deliberate one arriving later. Between them they cover most of what a docked assistant is asked:

• Make this email shorter and less formal.
• What does this error message mean?
• Summarize the selected text in three bullets.
• Give me two alternative subject lines.
• What does this spreadsheet formula do?
• Translate this paragraph into German.
• What does this command-line flag do?

A knowledgeable colleague would answer any of these without stopping to think. GPT-6 Luna also accepts images, so a simple question about a screenshot of what is on screen belongs on this profile too.

The pattern that follows is many small questions asked in the gaps of other work, none worth switching applications for. Answers that arrive quickly get asked for more often, which is exactly why the model behind them should be a cheap one. No response time is printed here, because latency depends on your connection, the prompt and OpenAI's load at that moment. Turning reasoning off removes the largest part of the wait that you control, and getting faster AI responses covers the rest.

Where GPT-6 Luna is the wrong choice

A budget profile fails in one particular way: it gets used on the task it is weakest at, and the answer is wrong in a way that reads as right. Move to the deeper profile, or raise reasoning effort, for anything whose answer depends on connecting several things correctly:

• Debugging from logs, a stack trace and code together, where the fault is an interaction rather than one line.
• Design and architecture decisions whose failure modes only show up where components meet.
• Comparing two long documents to find the contradiction or the changed obligation.
• Planning under real constraints, where a plausible but wrong answer is easy to produce.
• Anything where being confidently wrong would cost more than a slower answer.

When to use high reasoning effort has one question that separates the two kinds of problem reliably. The principle runs in both directions: use the model and the reasoning level that fit the task.

Why bringing your own key changes the arithmetic

This setup works because SideNote Pro is a bring-your-own-key assistant. It has no model and no AI account of its own, so the choices that decide the bill are yours:

The provider

OpenAI here, but the same kind of profile points at Anthropic, Gemini, DeepSeek or a model running on your own machine.

The model

GPT-6 Luna today. When something cheaper or better arrives, changing it is one field and no new software.

The reasoning level

How much of each request is spent thinking before answering.

The bill

OpenAI charges you directly for what you use, with no bundled allowance in between.

Three things are paid for separately, and it helps to keep them apart. The SideNote Pro licence is a one-time purchase for the software and includes no AI usage. OpenAI API usage is billed by OpenAI, from your own balance, at its published rates. A ChatGPT subscription is a third, separate product and pays for neither. What BYOK means covers the architecture.

Pay-as-you-go is not free, and heavy use costs more than light use. What it removes is a fixed monthly charge that arrives whether you used the assistant or not. At GPT-6 Luna's rates a small request costs so little that metered billing stops being something to watch, which was the appeal of a subscription, without the subscription.

The setup, in one block

Add a second profile on a more capable model with reasoning raised, for the problems that need it, and set Default profile to the fast one so new conversations open there.

The short version

GPT-6 Luna lowers the cost of an everyday OpenAI profile again: input at $0.10 rather than $0.20 per million tokens and output at $0.50 rather than $1.20, with the same context window and the same option to switch reasoning off. For the small requests that fill a working day, that is cheap enough to stop thinking about.

Pair it with a stronger profile for the problems that deserve one, and let it take everything else. For most of what you ask in a day, it is simply the right tool.