# The Missing Mode: Interactive Execution in Software
## Every Application Has Modes. They're All Missing One.
Vim has insert mode, normal mode, visual mode. Each one changes what your keystrokes do. Photoshop has selection tools, paint tools, transform tools. Excel has edit mode and command mode. Every serious application gives you different ways to interact with it.
But all of these modes share the same assumption: **the software waits for you.** You type, it records. You click, it responds. You submit, it processes. The human drives. The software reacts.
There's a mode that doesn't exist yet in mainstream software — one where the software works alongside you in real time, making decisions, asking questions, producing outputs, and revising when you correct it. Not a chatbot. Not a form wizard. Not a background job. Something in between all of them that none of them actually are.
Call it **Interactive Execution Mode.**
## What Exists Today (And Why It's Not Enough)
### Batch Mode
Submit a job. Wait. Get a result. This is how most backend processing works — file uploads, report generation, AI content creation. You throw input over the wall and hope for the best. If the assumptions were wrong, you start over.
### Chat Mode
Talk to an AI. Get text back. Conversational, flexible, but the output is just... text. It doesn't produce structured work products. It doesn't spawn tasks. It doesn't update records in your system. It's a conversation that lives and dies in the chat window.
### Form Mode
Fill out fields. Submit. Get a result or a confirmation. This is how TurboTax works, how onboarding flows work, how most SaaS configuration works. Linear. Rigid. If you don't know what goes in field 47, you're stuck. The form can't help you — it can only wait.
### Wizard Mode
A slightly fancier form. Step 1, Step 2, Step 3. Maybe some conditional logic. But still fundamentally linear, still dumb, still can't handle ambiguity. "It depends" is not a valid answer in a wizard.
### Copilot Mode
AI suggests. You accept or reject. GitHub Copilot, email autocomplete, smart compose. The AI is helpful but passive. It doesn't take initiative. It doesn't say "I notice you haven't addressed X — should I handle that?" It waits for you to type and then tries to finish your sentence.
Every one of these modes puts the human in the driver's seat with the software as a tool. That made sense before AI could reason. It doesn't make sense now.
## The Missing Mode: Interactive Execution
Interactive Execution Mode is what happens when the software is an active participant in getting work done. Not a tool you wield. Not an assistant that suggests. A collaborator that executes.
Here's what it looks like:
### 1. It Starts With What It Knows
The system doesn't begin with a blank form. It pulls in everything it already has — your files, your previous work, your project context, your preferences. If you're doing taxes, it already has last year's return, your uploaded W-2s, your bank transaction categories. If you're onboarding a new client, it has the intake template, previous similar clients, and your standard service agreements.
The session begins half-complete.
### 2. It Asks Questions at the Right Time
Not all at once. Not in a predetermined order. The system works forward until it hits ambiguity, then asks. "I see two addresses on file — which is current?" "This expense could be business or personal — which is it?" "You mentioned 5 years depreciation but standard is 7 — are you sure?"
The questions are contextual. They arise from the work, not from a form designer's imagination of what you might need.
### 3. It Works While You Answer
This is the key difference. In form mode, nothing happens until you submit. In Interactive Execution Mode, the system is spawning work in parallel. While you're answering question 3, the answers from questions 1 and 2 already triggered computations, lookups, document generation, or API calls running in the background.
By the time you finish the conversation, most of the work is already done.
### 4. It Shows Its Assumptions
"I'm assuming the standard deduction since your itemized total is lower — here's the comparison." The system doesn't just compute silently. It surfaces the decisions it made and lets you override them. Transparency isn't optional — it's how trust gets built.
### 5. It Handles Three States of Data
Every piece of information in the session exists in one of three states:
- **Input Data** — what you provided or what was already on file
- **Computed Data** — what the system derived (calculations, AI-generated content, lookups)
- **Changed Data** — what you corrected after reviewing computed results
When you change computed data, the system knows to re-derive anything downstream that depended on it. Change your filing status and the entire tax calculation cascades. Correct a client's industry classification and the risk assessment regenerates. This isn't a spreadsheet recalculating cells — it's a workflow re-executing affected steps.
### 6. It Produces Real Work Products
At the end of the session (or during it), you don't get a chat transcript. You get:
- Documents (contracts, reports, filings)
- Updated records (CRM entries, financial data, inventory)
- Created tasks (follow-ups, approvals, reviews)
- Stored files (generated PDFs, images, exports)
- Audit trail (what was asked, answered, computed, changed)
The conversation was the interface. The outputs are the point.
## Why This Didn't Exist Before
Three reasons:
### Ambiguity Required AI
Old software couldn't interpret "same as last year" or "bump it up about 10%" or "skip that part, it doesn't apply." Every input had to be structured, validated, typed. AI can now handle natural language inputs and map them to structured actions. The rigid form was a workaround for machines that couldn't understand humans. Now they can.
### Parallel Execution Required Modern Infrastructure
Working while the user answers requires async task execution, background job queues, real-time updates. The infrastructure for this (Celery, WebSockets, server-sent events) has only become mainstream in the last few years. Five years ago, most web apps were request-response only.
### Structured + Unstructured Required New Patterns
Interactive Execution Mode combines structured data (schemas, forms, databases) with unstructured interaction (conversation, clarification, natural language). The patterns for mixing these — function calling, tool use, structured output from LLMs — are brand new. A year ago, getting an AI to reliably fill out a JSON schema from a conversation was a research project. Now it's an API call.
## Examples: Where This Mode Changes Everything
### Tax Preparation
Instead of 100 screens of TurboTax forms, you have a guided conversation. The system pulls your documents, asks about changes from last year, surfaces deductions you might qualify for, computes as you go, and produces the filing. What takes most people an entire weekend takes an hour because the system is doing the work between your answers.
### Client Onboarding
Law firm, consulting firm, agency — any service business. Instead of emailing a PDF intake form, the system walks the client through questions, pulls in data from their uploaded documents, creates the engagement letter, sets up the project structure, assigns initial tasks, and sends the welcome package. By the time the conversation ends, the client is fully onboarded.
### Sales Rep Training
New affiliate or sales rep joins. Instead of watching training videos, the system walks them through the product interactively. "What's your target market?" generates customized pitch materials. "Try explaining this feature" evaluates their description and coaches. "Here's a practice scenario" simulates a sales call. The training produces real assets (their pitch deck, their prospect list, their talk track) not just a certificate of completion.
### Insurance Quoting
Agent sits with a customer. Instead of toggling between 5 carrier portals, the system asks the customer questions conversationally, fills multiple carrier applications simultaneously in the background, surfaces the best quotes as they compute, and flags coverage gaps. The agent looks like a genius. The customer gets a better result. The back-office paperwork is already done.
### Project Scoping
Client describes what they need. The system asks clarifying questions, references similar past projects, estimates costs as the scope develops, identifies risks, and produces a preliminary SOW. The client sees the scope and cost evolving in real time as they answer questions. Changes are instant because the system re-derives downstream estimates as inputs change.
## The Architecture
Interactive Execution Mode isn't one feature — it's an orchestration layer that connects existing capabilities:
- **Templates/Schemas** define the structure of what needs to be collected and produced
- **AI** handles the conversational interface, ambiguity resolution, and assumption-making
- **Objects/Functions** perform the actual computation (tax calculations, document generation, API calls)
- **Tasks/Jobs** track the work being spawned (with billing, storage, and audit trail)
- **Files** store the work products (documents, exports, generated content)
- **Real-time layer** keeps the user updated as background work completes
The mode itself is the conductor. It knows the template (what we're trying to produce), the current state (what we know, what's missing, what's computed), and the execution plan (what to run next, what to ask, what to re-derive).
## Why This Matters
Every year, software gets more powerful and harder to use. Features pile up. Menus get deeper. Settings multiply. The solution has been better documentation, more tooltips, simpler UIs. But the root problem isn't complexity — it's that the human has to drive everything.
Interactive Execution Mode flips the relationship. The software drives. The human steers. You don't need to know where every setting is or what every field means. You just need to answer questions and correct assumptions. The software does the rest.
This is what AI was supposed to enable — not chatbots that write poetry, but software that actually works alongside you to get things done. Software with a mode that didn't exist before because it couldn't. Now it can.
The mode is missing. Time to build it.