For the entire history of business software, there has been a human in the middle.
Someone types the invoice into the accounting system. Someone logs the call in the CRM. Someone copies the meeting notes into the project tracker. Someone reads the contract and flags the renewal date. Someone scans the resume and enters the candidate into the ATS.
The software stores what the human types. It retrieves what the human queries. But it doesn't understand any of it. It has never understood any of it. Every business application you've ever used is, at its core, a very sophisticated filing cabinet. It holds information. It does not comprehend information.
That just changed.
What "software can read" actually means
Large language models gave software the ability to read text and understand what it means. Not search for keywords. Not match patterns. Understand.
Software can now read an email and know it's about a contract renewal, not a support ticket. It can listen to a meeting recording and know that the client is unhappy, even though nobody said the word "unhappy." It can look at a Slack thread and understand that two teams are working on the same problem without knowing it.
This sounds incremental. It is not. It is the most consequential change in business software since the move to the cloud, and it invalidates the core assumption behind almost every tool your company uses.
That assumption is: a human will be the translator between the real world and the system.
When software couldn't read, you needed humans to read things and then type structured data into fields. That was the only way to get information into a system in a form the system could use. Every business application was designed around this constraint. Every workflow assumed a human in the loop, translating messy reality into clean data.
That constraint just lifted. And the implications go far beyond any single category of software.
The pattern is everywhere
Consider CRM. The entire category was built on the assumption that salespeople would log their activities. They didn't. The data was always bad. So the market built an ecosystem of ten or more supplementary tools (call recorders, enrichment platforms, forecasting engines, sequencing tools) to compensate for the fact that the core system couldn't capture information on its own. Billions of dollars in market cap exist because CRM couldn't read an email.
Now consider what happens when the system can read the email itself. It can read every email, every call transcript, every Slack message, and build a continuous, accurate picture of every customer relationship without anyone typing anything. The supplementary tools become redundant. The category restructures around a fundamentally different architecture.
But CRM is just one example. The same pattern applies across the enterprise:
Legal. Contract management systems require humans to read contracts and tag key terms, dates, and obligations. Software that can read the contract itself can extract every clause, flag every risk, and track every deadline automatically. What's left for the human is exceptions.
Finance. Expense management, invoice processing, and audit workflows all depend on humans reading documents and entering data. Software that can read receipts, invoices, and bank statements can categorize, reconcile, and flag anomalies without manual entry. Someone still signs off. Nobody enters the numbers.
HR. Applicant tracking systems require recruiters to read resumes and manually score candidates. Software that can read a resume, a cover letter, and a LinkedIn profile can surface the most relevant candidates and explain why. The recruiter makes the final call, on a shortlist that's smaller and already ranked.
Customer support. Ticketing systems require agents to read tickets, categorize them, and route them. Software that can read the ticket, understand the customer's history, and draft a response can resolve straightforward issues on its own. Agents spend their day on the tickets that were never going to be easy anyway.
In every case, the pattern is the same. A human was doing translation work (reading something, understanding it, entering structured data) because the software couldn't. Now the software can. The human's role shifts from translator to decision-maker.
Why this isn't "automation" in the old sense
Previous waves of automation replaced repetitive physical tasks or rule-based digital tasks. If you could write an if/then statement to describe the work, you could automate it.
This is different. Reading comprehension is not rule-based. Understanding that a customer email is really about pricing concerns even though it's phrased as a question about features requires judgment, not rules. Recognizing that a meeting went poorly even though everyone was polite requires social intelligence, not pattern matching.
Software that can read doesn't just automate data entry. It automates understanding. And understanding was the thing we assumed only humans could do.
This is why the impact will be broader than most people expect. It's not about making existing workflows faster. It's about eliminating entire categories of work that existed only because software couldn't comprehend what it was storing.
What companies should do about it
The practical implication is straightforward, even if the execution is hard: every tool in your stack was designed around the assumption that a human would be reading, interpreting, and entering data. That assumption is now optional.
The companies that move first will do three things:
First, audit the translation work. Look at every workflow where a human reads something and then types something into a system. That's the translation layer. In most companies, it accounts for 30-40% of knowledge worker time. Not all of it can be replaced immediately, but all of it should be examined.
Second, evaluate your tools by their architecture, not their feature list. The question isn't whether your CRM or your ATS or your contract management system has "AI features." The question is whether it was built from the ground up for a world where software can read, or whether AI was bolted onto an architecture designed for human data entry. The difference is structural, and it compounds over time.
Third, start small and measure. Pick one workflow where a human is doing translation work. Give that team a tool built for the new paradigm. Measure what changes in a month. The proof point will be obvious, and it will make the case for everything that follows.
Software can read now. Every tool your company uses was built for a world where it couldn't. The gap between those two facts is where the next decade of enterprise software gets built.
