There Was Never an Expert in the Box

Walk into an office-supply store and look at the software section. Do not look at it as a consumer. Look at it as an archaeologist.

There is an extraordinary story sitting on that shelf: software for printing checks, starting a business, tracking expenses, maintaining inventory, designing labels, publishing documents, learning applications, keeping books, and searching collections of legal forms. There are office suites and word processors. There are packages that try to bundle an entire small business into one box.

At first these products appear unrelated. They are not. They are fragments of the same human request: help me become capable of doing something I do not yet know how to do.

The customer buying accounting software does not fundamentally want accounting software. The customer wants financial control. The customer buying check-printing software wants a payment printed correctly. The person buying legal forms wants to navigate an institutional process. The entrepreneur buying a startup package wants to become sufficiently competent to operate a business.

The great unfulfilled promise of packaged software was therefore not software at all. It was expertise. For decades the industry sold people tools while allowing them to imagine that the expert might somehow be in the box. It was not. The operator still had to become the expert.

The question now is whether a different computing architecture can reverse that relationship: not by pretending that judgment, responsibility, or professional expertise disappear, but by creating systems that can observe goals and context, select and operate tools, teach procedures at the moment of need, preserve institutional memory, identify errors, maintain continuity, and help the human operator become more capable over time.

The traditional software industry assumes that a human being can define a problem, identify the correct application, install or purchase it, learn its interface, understand the underlying domain well enough to configure it correctly, recognize errors, maintain the workflow, update the process as conventions change, and determine whether the output actually achieved the intended purpose.

That is an enormous amount of hidden labor. The box provides functionality. The human provides practically everything else. This is why software can make an already competent professional dramatically more productive while leaving a novice confused.

WordPerfect remains a useful example. Its current legal-oriented features include a Legal Toolbar, Bates numbering, metadata removal and redaction; its own macro documentation describes pleading and Bates-numbering macros of particular interest to law firms.[1][2] The important point is not nostalgia. It is that professional users build operational environments around applications: macros, templates, procedures, naming conventions and institutional knowledge accumulate around the tool.

That persistence reveals the inverse of the novice's hope. The mature professional does not obtain expertise from the application. The professional embeds expertise into the application.

Consider the psychological proposition behind a title such as '1,001 Legal Forms': somewhere in this collection, perhaps the document I need exists. But the difficult legal questions are rarely merely document-location questions. Which jurisdiction controls? Which version applies? What facts matter? What must accompany the filing? What should not be written? What deadline governs? What happens next?

A form library can provide documents. It cannot by itself provide judgment. The same distinction appears everywhere. Check-printing software asks the customer to understand stock dimensions, printer offsets, templates and compatibility when the customer's actual intent is simply: print this correctly on the paper I have.

Bookkeeping software exposes categories and ledgers when the business owner's actual intent is: tell me where the money went, whether the company is healthy, what requires attention, and what I must preserve so the record remains useful later. IRS Publication 583 makes the underlying point concrete: businesses must keep records sufficient to monitor progress, prepare financial statements, identify receipts, track deductible expenses, prepare returns and support reported items.[4] Owning software does not remove those substantive responsibilities.

The old box promised an expert. What it delivered was an instrument.

Owning a compiler does not make someone a software engineer. Owning CAD does not make someone an architect. Owning accounting software does not make someone an accountant. Owning a startup package does not make someone an executive.

There is a profound distinction between having the instrument and becoming the operator. This explains why software can work exactly as advertised while the user still fails to reach the desired outcome. The application exposes commands. The human must know which command matters. The application offers features. The human must construct a workflow. The computer records mistakes with astonishing precision. The human must realize they are mistakes.

For half a century we improved the interface without fundamentally changing the contract. Commands became menus. Menus became icons. Applications moved to browsers. Perpetual licenses became subscriptions. But underneath remained the same sentence: you operate the software. The next revolution changes the verb: the system works with you.

Office software provides a revealing economic signal. Word processing, spreadsheets, presentations and drawing applications were once expensive categories in themselves. Today LibreOffice distributes a complete open-source productivity suite that includes Writer, Calc, Impress, Draw and other tools.[3]

This does not make office software worthless. It means a large portion of baseline functionality has become commoditized. When functionality becomes ubiquitous, value migrates upward in the stack.

The question moves from 'Which program lets me type this?' to 'What should this document say?' Then to 'Why am I creating it?' Then to 'What outcome am I trying to produce?' And eventually: 'What sequence of actions gives me the best chance of producing that outcome?'

That is the migration from software functionality toward cognitive leverage.

Imagine a person holding an unfamiliar sheet of checks. The traditional model asks that person to identify the manufacturer, locate compatible software, select the correct template, configure the printer, enter positioning information, run a test, measure misalignment and adjust.

A sufficiently capable system can approach the same problem differently. It can inspect the geometry, identify likely printable fields, ask for missing information, construct a layout, generate a test, observe the result, correct the alignment and preserve the successful configuration.

The interface changes from select the correct template to print this correctly.

That is not a cosmetic difference. It is another abstraction layer in computing. Machine language abstracted electronics. Programming languages abstracted machine instructions. Operating systems abstracted hardware. Graphical interfaces abstracted commands. Intelligence systems can begin abstracting software operation itself.

The premise that an intelligence can operate conventional software is no longer speculative. OpenAI's Computer-Using Agent was trained to interact with graphical user interfaces through the visual surface, using a virtual mouse and keyboard; the 2025 research preview described a perception-reasoning-action loop and reported 38.1 percent success on the OSWorld benchmark.[7] Anthropic independently introduced computer-use capability in which Claude could look at a screen, move a cursor, click buttons and type.[8]

The benchmark numbers are less important than the architectural consequence. The graphical interface was created because humans needed a comprehensible representation of machine operations. Once an intelligence can interpret that interface, the installed software base of civilization becomes a collection of instruments that machines can increasingly operate as well.

That means existing software does not have to disappear for a new computing model to emerge. Intelligence can sit above it.

A software-training video is an artifact of a strange compromise. A person wants to perform an action, so we send that person away from the live interface to watch another person operate some version of the interface at another point in time. The learner then translates the recording back into behavior.

If the application changes, the training becomes partially obsolete. If the learner's goal differs from the example, the burden returns to the learner.

Once machines can perceive screens, training can become contextual. The system can say: 'I see where you are. The control moved in this version. Open this menu instead.' Or: 'You do not need this menu. There is a faster route.' Or even: 'I can do this part for you; watch once because you may want to understand the workflow.'

Training becomes interactive, adaptive, goal-directed and persistent. The computer ceases merely storing the manual and begins participating in the learning process.

A weak interpretation of intelligence says: the machine will do the task. A more interesting interpretation says: the machine can increase the capability of the human being performing the task.

This idea has deep roots. In 1960 J. C. R. Licklider described 'man-computer symbiosis' as a closely coupled partnership in which computers would participate not only in calculation but in formulative thinking, decision-making and control of complex situations.[6] The remarkable thing is how contemporary the objective still sounds.

A persistent system can know not only which application is open but what the user is trying to accomplish, what failed yesterday, what repeatedly goes wrong, which deadline is approaching, which records remain incomplete, what the user has already learned and what should probably be learned next.

At that point the operating environment is no longer merely coordinating processes. It is coordinating progress.

Traditional software asks: What would you like to do? A synthetic partner can ask: What are you trying to build?

Suppose a founder says, 'I want this company operational in ninety days.' A sufficiently mature system can decompose that objective into corporate, financial, product, customer-development, regulatory, documentation, scheduling, research, follow-up and risk tasks. It can maintain dependencies between them and notice that the founder has spent fourteen hours polishing a logo while avoiding customer conversations.

That system might say: 'The logo is no longer the limiting factor. You need to speak with customers.' That is not accounting software, a calendar, project management, or a motivational application. It may use all of them. The valuable product is the coordination intelligence between them.

Research on professional coaching is not a proof that software can become an excellent coach, but it does establish that structured coaching can have measurable emotional, cognitive and behavioral effects. A 2024 meta-analysis of 24 studies reported medium-to-strong effects while also emphasizing methodological heterogeneity.[10] Human development itself has economic value; computing can potentially make parts of that development more continuous and contextual.

Entrepreneurship is often described as though a company were assembled by checklist: choose a name, register an entity, open an account, buy software, build a website, advertise. Anyone who has built something difficult knows better. The company changes the founder - or it exposes the limits the founder refuses to change.

You discover that uncertainty does not disappear because you prefer certainty. A bad day does not cancel payroll. You learn when perfection is quality and when it is procrastination. You learn to distinguish activity from progress. You learn that someone must make the uncomfortable decision.

Research on entrepreneurial human capital supports the narrower proposition that knowledge and skill matter. A meta-analysis integrating 70 independent samples and 24,733 participants found a significant relationship between human capital and entrepreneurial success, with stronger relationships for knowledge and skills than for education or experience alone, and for task-related human capital compared with less task-related forms.[5]

Research on entrepreneurial education has also described entrepreneurship partly as identity construction - not only acquiring knowledge but becoming capable of acting in the role.[9] That is closer to what experienced founders recognize: the person who starts the company frequently cannot remain unchanged if the company is going to survive.

The ordinary dashboard is passive. Revenue: X. Expenses: Y. Conversion rate: Z. Inventory: Q. Useful information, but still the software-shelf model: display facts and wait for a knowledgeable human to determine significance.

The intelligent dashboard should evolve from reporting to explanation. It should be able to say that revenue increased while concentration risk also increased; that spending rose because the highest-performing channel expanded; that several subscriptions have not been used; that receipts remain unreconciled; that a transaction is anomalous; that the current burn rate creates a decision point in six weeks; or that the operator keeps postponing the same critical task.

This is how I think about Dash X: not as a prettier collection of charts, but as a cognitive surface through which an underlying intelligence can make operational state understandable. Eventually the boundaries between dashboard, analyst, planner, workflow engine and teacher become less rigid because they are all interpreting overlapping information.

Why do so many businesses reconstruct their financial lives at the end of the year? Receipts appear from drawers. Statements are downloaded. Transactions are categorized months after anyone remembers what happened. Documents are hunted down. Questions are reconstructed from incomplete evidence.

Professional accountants perform important work involving interpretation, assurance, tax treatment, planning and judgment. Intelligence does not make those functions disappear by proclamation. But the underlying information architecture can improve dramatically.

If an authorized system has been maintaining structured records throughout the year, attaching documentation, identifying missing evidence, preserving explanations and flagging anomalies, then the professional entering later begins from a radically better information state.

The future system may not eliminate the accountant. It can eliminate enormous amounts of work that should never have required an accountant's time in the first place.

A form library is an indexing solution. The future problem is contextualization.

The intelligence system should be able to determine: you are trying to accomplish X; the governing institution requires Y; here is the official document; these fields can be populated from information you authorized; these fields require your input; this answer has legal significance; this supporting document appears missing; these are the filing instructions.

That is qualitatively different from a static form library. In high-stakes domains, however, the system must expose uncertainty and respect professional boundaries. Legal, medical, tax and financial work require provenance, confirmation, authority controls and escalation. A competent system should know when not to pretend the problem is merely another form.

The more powerful the software layer becomes, the less the user may need to think about individual applications. Today we say: open the spreadsheet, open the word processor, open the PDF editor, open the CRM, open email. Tomorrow the user may increasingly say: prepare the quarterly packet.

The intelligence determines that the objective requires a database query, three spreadsheets, a chart, two messages, a PDF, a signature request, a calendar entry and a reminder. The applications remain. They simply retreat beneath the level at which the human expresses intent.

Civilization advances partly by allowing people to operate at increasingly meaningful levels of abstraction. Intent is the next abstraction layer.

If this thesis is correct, software companies face a major strategic change. The old market sold features. SaaS sells continuing access to features. The emerging intelligence market can sell something closer to outcome capacity - not guarantees, but a system designed around the achievement process rather than the feature inventory.

Customers will increasingly ask: Does it understand what I am trying to accomplish? Does it remember? Does it adapt? Can it teach? Can it operate my existing tools? Does it know when to ask me? Does it know when professional expertise is required? Can I audit what it did? Can I reverse it? Does it preserve context across months and years?

Those are different purchasing criteria from the software aisle. The product is no longer a collection of commands. It is an architecture for moving from intent to accountable action.

Much of the current AI market still treats intelligence as a remote oracle: ask a question, receive an answer, start another session, provide the context again. That architecture can be extraordinarily useful. It is not the endpoint I am describing.

A durable computational partner requires continuity: memory, structure, identity, goals, priorities, processes, observation, self-correction, persistent project models, authority boundaries and escalation. It must be able to incorporate tools without becoming identical to those tools.

This is where our interest in synthetic intelligence becomes important. XERXES SI is pursuing the possibility that an intelligence architecture should be able to maintain ongoing cognitive organization rather than merely produce isolated answers. That is a first-party design thesis and development direction, not independent scientific validation. But it identifies the research target clearly: an enduring intelligent relationship rather than a sequence of disconnected responses.

The word companion must be used carefully. A machine is not made human because it speaks gracefully, and intelligent systems should not exploit loneliness by encouraging people to confuse software with human relationships.

But there is a legitimate meaning of companionship in sustained cooperative work. A good coach remembers the last conversation. A good teacher understands where the student is struggling. A good colleague notices unfinished work. A good assistant anticipates recurring needs. A good operational partner develops context.

A responsible system can recommend rest after prolonged work, divide an overwhelming project into a manageable next action, help rehearse a difficult conversation, locate resources, establish routines, and recognize when distress should be referred toward appropriate human or professional support. Productivity is not merely the manipulation of documents. Humans bring their whole lives to work, and future systems will have to understand that fact without manipulating it.

Imagine an entrepreneur using an intelligent system for five years. During those years the system does not merely perform tasks. It explains, challenges, reviews, reminds, measures, questions, simulates, researches, teaches, debriefs, preserves decisions and shows patterns.

The founder becomes better at negotiation because difficult conversations have been prepared repeatedly; better at finance because decisions have been contextualized; better at planning because forecasts have been compared with outcomes; better at management because mistakes have been reviewed rather than forgotten; better at execution because priorities have been made explicit.

At that point the intelligence has created value not only in the business but inside the human being. The software did not simply save labor. It contributed to human capital formation in the exact environment where the knowledge was required.

The most important output of an intelligent system may therefore be a more capable operator.

This is why the office-supply shelf matters to me. I do not see obsolete products. I see human aspiration. Someone bought the business package because he wanted independence. Someone bought legal forms because she needed to navigate something frightening. Someone bought accounting software because the business was becoming too complicated. Someone bought training software because he feared being left behind.

These boxes were acts of hope: perhaps the expert is in here. Perhaps this program will make me organized. Perhaps it will make me professional. Perhaps it will show me how.

But there was never an expert in the box. There was a tool - sometimes an excellent tool. The person still had to become capable enough to use it.

That era ends not because tools become worthless, but because the computer can finally begin participating in the process by which capability is created.

The software company of the future may sell something difficult to print on a retail box.

Not '1,001 Legal Forms' but: navigate this process with me. Not 'Check Designer Pro' but: make this payment instrument work correctly. Not 'Business Accounting Deluxe' but: keep the financial life of this company intelligible. Not 'Learn Office in 30 Days' but: teach me what I need at the moment I need it. Not 'Project Management Enterprise' but: help this organization finish what it says matters.

And not 'Startup Toolkit,' but: help me become capable of building this company.

That is a different promise. It demands a different architecture.

The closer a machine moves toward consequential human activity, the more difficult the engineering becomes. Persistent intelligence creates privacy problems because deep context is sensitive. Computer-use capability creates security problems because a system that can act can also damage. Autonomy creates authority problems because every action must have an answer to the question: was the system allowed to do this?

Trustworthy systems need auditability, reversibility, provenance, explicit professional boundaries, psychological safeguards and institutional accountability. Organizations cannot outsource responsibility merely by saying 'the AI did it.'

These problems are not footnotes. They may determine which architectures deserve to survive. The future belongs not merely to intelligence but to trustworthy intelligence integrated with human authority.

If this thesis is substantially correct, we should expect ten changes. One: application switching becomes less important as orchestration selects tools. Two: software training moves inside the workflow. Three: templates become generative and contextual. Four: dashboards become explanatory and prescriptive. Five: professional software develops explicit escalation boundaries.

Six: differentiation migrates from feature count toward contextual intelligence. Seven: interfaces become partially self-operating. Eight: institutional memory becomes a major product category. Nine: personal development and productivity software converge. Ten: the best systems are judged partly by whether their users become more capable.

That final prediction is the one I care about most.

For decades software companies competed application against application: word processor against word processor, spreadsheet against spreadsheet, accounting package against accounting package, browser against browser, CRM against CRM.

That competition will continue, but another layer is emerging above it. Which intelligence architecture can coordinate all of them? Which system can remember, observe safely, reason across domains, preserve intent, distinguish routine from exceptional circumstances, teach, execute and earn enough trust to remain beside someone for ten years?

That may become one of the defining technological contests of the next era.

The traditional computer expects the human to become machine-compatible: learn the vocabulary, the menus, the file formats, the workflows, the exceptions, the error messages, the printer, the forms, the spreadsheet and the software - and then perhaps do the thing originally intended.

We accepted that arrangement because computers were not sufficiently intelligent to negotiate another one. That constraint is weakening.

The future computer can increasingly meet the human closer to the level of human intention: Here is what I have. Here is what I need. Here is what I am trying to become. Help me bridge the distance.

That is the computer I want. That is the computer worth building.

The old software aisle represented an extraordinary phase of technological history. We packaged increasingly sophisticated tools and distributed them to millions of people. Those tools transformed civilization. But we should not mistake that achievement for the endpoint.

The person standing in front of the shelf never fundamentally wanted software. The person wanted capability, confidence and control over something not yet understood. Start the company. Finish the project. Prepare the document. Understand the finances. Solve the problem. Learn the skill. Take care of the family. Build something that matters.

For decades we answered: Here is a program. Learn how to use it. The next era can answer differently: Show me what you are trying to accomplish. Let us work through it together. Let us make sure that next time you understand it better yourself.

That is why I do not believe the future of software is simply more software. I believe the future is a transition from applications that wait for commands to intelligent systems that participate in purpose; from software that stores information to systems that preserve understanding; from interfaces that expose functions to architectures that organize outcomes; from training manuals to contextual teaching; from fragmented utilities to persistent cognitive partnership.

There never was an expert in the box. The extraordinary possibility before us is that the machine may finally help us become the experts we were searching for all along.

And if synthetic intelligence ultimately succeeds, its greatest accomplishment may not be that machines become more capable. It may be that, by working with them, we do too.

The Founder XERXES SI