QNFA: the deep-thinking switch.

OMEGA has a switch that changes how hard it thinks. It ships off. It stays off for most of what you will ever ask it. And about once a week, on the right kind of problem, it is the difference between a plan that survives three days of real work and a plan you quietly abandon by Wednesday.

The engine that runs every normal turn is Neural-Fractal Agentic AI™ (NFA), which I wrote about in an earlier post. Short version: it splits work into small, scoped units and gives each one only the context it needs, which keeps answers fast and the token bill sane. The switch sits above that. Flip it and you get Quantum Neural-Fractal Agentic AI™ (QNFA), an optional deep-cognition mode for long-horizon work. Same assistant, same memory. What changes is how long it is willing to sit with a problem before it acts.

About the name, briefly

I will handle the obvious objection first. Yes, the name contains the word quantum. No, your Mac has not sprouted qubits, and I am not going to pretend otherwise. The name points at the family of optimization math we borrowed for weighing many candidate plans at once. It describes the lineage of the technique, not the hardware on your desk. Any vendor telling you their assistant is quantum in the physics sense, on consumer hardware, in 2026, deserves your full skepticism. What the mode actually does for you is the part that matters, so that is what the rest of this post is about.

What changes when you flip it

The best analogy I have is chess clocks. Blitz and classical chess are played by the same player with the same knowledge. What differs is the clock, and the permission the clock gives you to sit with a position instead of banging out the obvious move. NFA is OMEGA playing blitz: pick the most plausible approach, commit early, execute. That is correct for most work, and it is why blitz is the default. QNFA is the same player on a classical clock.

Concretely, two things change. First, reasoning gets more passes. Instead of producing a plan and executing it, OMEGA produces a plan and then attacks its own plan. It hunts for the step most likely to fail and the assumption carrying the most weight, revises, and attacks again. You already do this with your own plans when the stakes are high. QNFA just refuses to skip it.

Second, it explores more before committing. Standard mode picks a direction quickly because on most problems the obvious direction is right. Deep mode deliberately holds several directions open and spends real time on candidates that will probably lose, because occasionally the runner-up is the approach that survives contact with the details. An architect sketches a few floor plans in cheap pencil before anyone pours a foundation. The sketches are not waste. They are the cheapest place to be wrong.

What does not change is authority. Your model choices and your approval settings still apply, and nothing gets swapped in behind your back. QNFA is more thinking, not different permissions.

When I actually flip it on

Three situations, from my own use of the product.

Multi-day builds

When I take an idea into Project Canvas, the path runs from idea to a plan laid out as nodes, then into real code with live preview and diffs. On a build that will take days, the plan I commit to on day one is the structure I have to live inside on day three. A shallow plan does not fail loudly. It taxes every later step: a wrong module boundary here, a missing migration there, until the cost of the early shortcut is larger than the build itself. So before a multi-day build I flip QNFA on for the planning conversation, let it spend its minutes, read the plan it lands on, and then usually flip it back off for the execution grind. Deep thinking is for deciding the shape. The typing is fast either way.

Plans that run unattended

The second case is anything that will run without me watching. Automations in OMEGA are built in plain English and run on triggers and schedules, including on an always-on runner, which means an automation that fires at 3 a.m. deserves more scrutiny than a task I supervise live. Nobody is there at 3 a.m. to notice the weird case. Under QNFA, the planning pass spends its extra time exactly where unattended things die: what happens when a step returns an empty result, and what happens when a trigger fires twice in the same minute. I would rather wait a few minutes at design time than debug a silent failure a week later.

Ambiguous goals

The third case is when I cannot fully specify what I want. Goals in OMEGA accept objectives like "get my side project ready to show people," which is a real goal and also not a spec. Standard mode handles ambiguity the way a good junior engineer does: pick a reasonable interpretation and start. Usually that is fine. But when the interpretations genuinely diverge, early commitment is expensive, and this is where the deep mode earns its keep. It maps the readings of the goal before acting, notices that demo-ready and open-source-ready are two different projects, and surfaces that fork to me as a question instead of an assumption. The most valuable thing a deep mode can produce is sometimes not a plan at all. It is the question you would have wanted asked.

The bill is paid in time

I want to be blunt about the cost, because the cost is the reason for the default. QNFA is slower. Seconds become minutes. You will watch it thinking, and on a genuinely hard planning problem you will have time to go make coffee. There is no way around this. The entire point of the mode is spending more compute per decision, and compute takes time.

There is a second-order cost too. More passes means more model calls, so if your deep turns route to paid cloud models, they draw more from your budget, which OMEGA meters and caps like everything else. If they route to a local model through Omega-MLX on Apple Silicon, the extra passes cost you nothing but electricity and patience. Either way, the cost you feel day to day is the wait, and I would rather you pay it knowingly, on the handful of problems that deserve it, than pay it by accident on everything. Plan details live on the pricing page.

Why it ships off by default

Most turns do not need deep cognition. The median thing anyone asks an assistant is small: a lookup, a quick rewrite. Deep mode on a small question is not merely slower, it is often worse. An assistant that treats "rename this function" as a planning exercise delivers the answer late and occasionally delivers a stranger answer, because it talked itself out of the obvious one along the way. Overthinking is a real failure mode in people, and it is a real failure mode in machines.

There is also a trust argument, and I care about it more. A mode you flip is a mode you can reason about. When QNFA is on, you know why the spinner is spinning. When it is off, you know OMEGA will not quietly decide that your two-line question deserves nine minutes of contemplation and a corresponding bite out of your budget. Off by default is not modesty about the feature. It is the position that your time belongs to you, and that an assistant should escalate its effort when you ask it to, not when it feels inspired.

Plan modes elsewhere

OMEGA is not the only tool that noticed shallow planning is the bottleneck. Anthropic shipped Claude Ultraplan in April, a draft-plan-then-run mode, and the core interaction is genuinely right: you read the plan before the run instead of discovering it during the run. Cursor 3 has a Plan Mode in the same spirit inside the editor, alongside its multi-agent work, and if your whole working life is the editor, that is a sensible place for planning to live. Devin makes the further bet of running the engineering loop autonomously in a cloud IDE, which only works if you trust the plan enough to leave it alone. These are good products built by people who saw the same problem.

The difference with QNFA is scope and residence. Each of those modes lives inside its own product. QNFA is a posture of the whole assistant: the same switch deepens the same OMEGA, with the same 4-layer memory and Brain knowledge graph underneath, in a chat conversation and in a Project Canvas build alike. And because OMEGA is provider-portable, deep mode is not welded to one vendor. You can run it on whichever provider you have connected, with your own keys and no token markup, or keep it local on Apple Silicon. Swap providers mid-chat and the context comes with you.

I will concede the flip side. If what you want is the deepest possible coding-specific planning inside an editor, Cursor is further along on editor ergonomics than we are, and Anthropic's models need no endorsement from me. The case for QNFA is that planning depth should belong to your assistant, not to one app in your stack.

A rule of thumb

Here is the heuristic I actually use. If I can describe the finished output in one sentence and I expect to have it within the hour, the switch stays off. If the work will still be on my desk in three days, or I cannot yet say what done looks like, I flip it on and give the first conversation the minutes it wants.

Deep thinking is a tool with a cost, which is exactly why it is a switch and not a default. OMEGA runs natively on macOS 14 and up on Apple Silicon; grab it from the download page and try the switch on the gnarliest thing on your plate. Most days you will not need it. The day you do, seconds were never going to be enough.