About SuperTab

Inspiration

The original idea for SuperTab came from seeing a similar feature in Windsurf. It was basically autocomplete for actions: instead of constantly telling an AI what to do, it would understand what you were already doing and suggest the next step. We thought that idea should exist across the entire computer.

A lot of everyday computer use is made up of small and predictable actions. You open a verification email, click the website, paste the code, and continue. You read an action item in an email, open the relevant document, and start working on it. You begin writing about a meeting, then look at your calendar to find the time. None of these tasks are individually difficult, but doing them over and over adds a lot of friction.

SuperTab aims to make these actions feel like autocomplete.

What it does

SuperTab watches the current activity on your computer and suggests the most useful next action. The suggestion appears in a small popup beside your cursor. To accept the suggestion, press Tab, and SuperTab will execute it.

Right now, SuperTab can suggest actions such as:

Completing the text you are currently writing
Opening a relevant website
Switching to a matching tab if that website is already open
Opening an application
Clicking a relevant button or link
Using recent text, Gmail, or Google Calendar information as context

For example, if an email contains a verification code and a website, SuperTab can suggest opening the website first. Once you reach the verification field, it can suggest filling in the code. If you write, "I cannot make it because I have a meeting at," SuperTab can use recently seen information or calendar context to complete the sentence.

How Codex and GPT-5.6 fit into the project

We used OpenAI in two completely different parts of SuperTab.

Technology	How we used it
Codex	Codex was our development partner. We used it to plan, write, simplify, debug, and test the application.
GPT-5.6 Sol	Sol, Terra, and Luna run inside SuperTab. The selected model looks at the current desktop context and decides which action the app should suggest.

How we built it

SuperTab is a standalone Windows application built with C#, WPF, and .NET.

It uses Windows UI Automation to inspect the active application, focused element, visible text, browser tabs, buttons, links, and editable controls. It also keeps a limited buffer of recently seen text so that useful information from one application can help with an action in another application.

SuperTab also includes Firebase authentication and account preferences for choosing the model and reasoning level. Google integrations provide Gmail and Calendar context. A context inspector shows exactly what SuperTab sees, including the active element, buffered text, available controls, raw model output, and final suggestion.

How GPT-5.6 Sol powers the app

Inside the app, we use GPT-5.6 Sol as the main intelligence behind the suggestion engine. SuperTab sends Sol a compact version of the foreground activity, focused text, recent context, and currently available controls. Sol then decides what the user is trying to do and chooses the single best next action. It can also decide that there is no useful suggestion right now.

Sol does not return arbitrary computer instructions. Instead, it chooses from a small set of parameterized actions:

Autocomplete(text)
OpenTab(destination)
OpenApp(application)
ClickButton(control)
FocusControl(control)
NoSuggestion()

Controls such as buttons and links are given request-specific IDs. This keeps the model tied to controls that actually exist on the current screen. URLs are cleaned before being opened, and OpenTab switches to an existing matching tab when possible instead of opening duplicates.

We used strict tool schemas so that Sol returns one parameterized action instead of a paragraph describing what the app should do. The model is responsible for understanding the activity and choosing the action. The application is responsible for safely carrying it out.

The app can also run GPT-5.6 Luna or Terra when lower latency matters. We used Sol as the main high-quality configuration because it was better at understanding messy desktop context and choosing the correct action. The UI lets the user switch models and reasoning modes.

To make model behavior inspectable, SuperTab displays the raw GPT-5.6 tool output in the context inspector. This was extremely useful because we could see when Sol made the correct decision but the application rejected or incorrectly executed it.

How Codex helped me build it

We used Codex as our main development partner while building SuperTab. We started with the product idea and repeatedly tested the app on real desktop situations. We showed Codex what happened, explained why the behavior did not make sense, and used it to implement fixes.

Codex helped us:

Move the project from a Chrome extension toward a standalone Windows application
Simplify and reorganize the C# codebase
Build the WPF interface, authentication flow, and context inspector
Work with Windows UI Automation for text, focus, tabs, links, and buttons
Connect Firebase, Gmail, and Google Calendar context
Design the parameterized action system used by GPT-5.6 Sol
Debug suggestion latency, irrelevant background context, stale actions, duplicate tabs, and failed autocomplete execution
Build regression and live model tests for real use cases

The development process was very iterative. For example, when SuperTab suggested opening an unrelated background tab, we used the context inspector to show Codex the exact foreground state, available controls, and raw Sol output. Codex traced whether the mistake came from context collection, the prompt, the model response, post-model validation, caching, or action execution. We then changed the relevant layer and tested the same type of situation again.

I also used Codex to push back against unnecessary complexity. As the project grew, we repeatedly asked it to remove old suggestion systems, flatten directories, reduce the number of files, and keep the C# as readable as possible. This helped turn the project from several competing prototypes into one clearer pipeline.

Codex built and debugged the application with me, but GPT-5.6 Sol is the model used by SuperTab itself at runtime. Codex was the development tool. Sol is part of the product.

Challenges we faced

Figuring out what actually matters

Getting text from the screen was not the hardest part. The hard part was separating the current activity from all the random stuff exposed by an application.

Gmail is a good example. UI Automation might return inbox labels, subject lines, browser buttons, navigation text, message content, and the text currently being written, all at once. Early versions gave all of this similar importance. The model would sometimes suggest something from a random background tab just because it appeared somewhere in the context.

We learned that the focused element and active window need to define the task. Everything else should only provide supporting information when the current task needs it.

Making it fast enough

A suggestion is not useful if it appears after the user has already moved on. The first versions called the model too often, sent too much context, and felt slow and clunky.

We used Codex to profile the suggestion pipeline and reduce the amount of text sent to GPT-5.6 Sol. We stopped making new calls when the meaningful context had not changed, briefly cached decisions, and separated fast local context collection from model reasoning. There is still a lot to improve, but the suggestions now feel much closer to real-time.

Preventing stale actions

Desktop state changes constantly. A suggestion could be correct when it is created, but stale by the time the user presses Tab.

SuperTab attaches actions to Windows UI Automation identities and checks the relevant state again when the action runs. However, we also learned that these checks can become too aggressive. At one point, GPT-5.6 Sol correctly created an arXiv PDF URL from a visible paper ID, but SuperTab rejected it because the complete URL did not already appear in the captured text. Sol was right and our validation was wrong. We showed the raw output to Codex, traced every hard rejection after the model call, and replaced brittle exact-text checks with sanitation and more practical execution logic.

Knowing when to suggest nothing

Early versions suggested actions just because they were available. If a tab existed, SuperTab might suggest opening it even when it had nothing to do with the current task.

Then we pushed filtering too far and created the opposite problem. The model started abstaining during extremely obvious situations.

The current version uses soft abstention. GPT-5.6 Sol can return no suggestion when every action would be irrelevant or speculative, but it is pushed toward making a suggestion when there is a clear next step in the foreground activity.

Context, memory, and privacy

Continuously collecting desktop context can use a lot of memory and can expose sensitive information. SuperTab keeps its immediate context bounded, pauses around protected fields, avoids typing into password controls, and does not save raw screenshots as long-term memory.

Instead of saving everything, the longer-term goal is to use the model to decide which pieces of text are actually valuable, remove redundant information, timestamp them, and store them in a form that can be searched later.

What We learned

The biggest thing we learned is that desktop intelligence is mostly a context problem.

Generating an action is easy compared to understanding what the user is actually trying to do. More context does not automatically make the result better. In many cases, it makes the result much worse.

The context needs a clear order:

The focused element shows what the user is doing right now.
The active window explains the current task.
Recent text, email, calendar, and memory can provide missing information.
The model decides whether a concrete action would actually move the task forward.

We also learned that the model and the execution system should have different jobs. GPT-5.6 Sol should make the intelligent decision. The application should provide simple tools and reliably carry out the selected action. Hard-coded rules should not try to replace Sol's understanding of the user's activity.

Using Codex also changed how we approached debugging. Instead of only describing that a suggestion felt wrong, we added tools that exposed the full decision pipeline. Being able to inspect the context, action options, raw GPT-5.6 Sol output, selected action, and rejection reason made it possible to separate model mistakes from application mistakes.

What is next

We want to improve context extraction for complicated websites and applications, reduce suggestion latency even further, add more integrations, and make personalization more useful over time.

The long-term goal is for SuperTab to learn common workflows without making the user manually build automations. Your computer should understand what you are already doing, offer the next useful step, and let you accept it with one key.