a16z: Enterprise Software That’s “Expensive and Hard to Use” Is the True Gold Mine for AI
TechFlow Selected TechFlow Selected
a16z: Enterprise Software That’s “Expensive and Hard to Use” Is the True Gold Mine for AI
SAP Is Overpriced to the Point of Absurdity—Yet No One Dares to Switch; a16z Bets on AI to Rewrite the Future of Enterprise Software.
Navigating Web3 tides with focused insightsAuthors: Eric + Seema Amble
Translated and edited by TechFlow
TechFlow Introduction: Upgrading from SAP ECC to S/4HANA costs $700 million, takes three years, and requires borrowing 50 consultants from Accenture—yet the world’s largest enterprises still rely on it. In this article, a16z unpacks a counterintuitive investment thesis: the future winners won’t be companies that “replace SAP,” but those that make SAP programmable and easier to use. This framework offers invaluable insight into where real opportunity lies in the enterprise AI landscape.
Full Text Below:
AI startups and their customers have focused attention on entirely new capabilities—and the products they enable: elegant voice agents, workflow automation tools, and text-generation application platforms.
These categories already host many exciting companies—and more will emerge (we’ve invested in several!). But AI’s most significant impact will come from something far less glamorous yet vastly more valuable: helping organizations extract greater value from the massive software estates they already run. There’s a question that sounds almost offensive—but anyone who has spent just one week inside a Fortune 500 company instantly understands it: Why are people still using SAP (and ServiceNow, Salesforce)?
The short answer is: SAP—or any major legacy system of record—holds the core data of the enterprise that uses it. More importantly, companies have layered extensive customizations on top of it and built around it specific processes and responsibilities—many of which aren’t even documented. The cost of migrating away is painful, expensive, and time-consuming—often requiring an army of consultants, multiple years, and hundreds of millions of dollars. Migrating from SAP ECC to SAP S/4HANA can cost $700 million, take three years, and require a team of 50 consultants from Accenture. And even after migration, the software often only generates static, read-only reports. Only now—with AI—is there a genuine opportunity to upgrade, customize, replace, and better access and use the data embedded within these systems of record.
Ultimately, AI’s goal may not be to “replace SAP/ServiceNow/Salesforce,” but rather to make them more programmable and more accessible. Winners will be platforms that (1) enter transformation budgets with measurable risk reduction and accelerated timelines—and then (2) expand as trusted control planes into daily operations, progressively decomposing legacy UIs into composable, governed, AI-assisted actions and lightweight applications. In other words: systems of record will persist; the interface layer, automation layer, and extension layer will become the new frontier of software.
SAP Is Painful—But We Still Use It
Let’s start with a quick primer on what SAP is. On the surface, these systems are hard to navigate, painful to modify—and yet somehow remain the operational backbone of the world’s largest enterprises. Here’s what using SAP feels like:
But that “somehow” is precisely where the opportunity lies.
The uncomfortable truth is: beneath the ugly UI and endless configuration, these systems are extremely powerful. They encode the enterprise’s authoritative data model, enforce compliance via permissions and controls, support scalable operational workflows, and integrate with dozens—or even hundreds—of downstream processes. They’re not “apps” in the consumer sense, but organizational memory accumulated in tables, roles, approvals, posting logic, and exception handling.
Replacing them isn’t just expensive—it’s highly risky. And the more a company invests in them—custom fields, workflows, pricing rules, reporting logic—the more these systems become moats built on migration cost—and even sources of competitive advantage. That’s why scalability is so powerful: every enterprise is unique; change is constant (new regulations, new products, new org structures); and these platforms survive precisely because they can bend to reality. The challenge is that this same scalability—which makes them valuable—also makes them fragile: each customization becomes a landmine for future upgrades; each workflow, a maze; each interface, a tax levied on everyone forced to use it.
This fragility is ubiquitous. Despite widespread CRM adoption, user satisfaction remains uneven; ERP customization is consistently accompanied by schedule and budget overruns. Employees are drowning in fragmented workflows—digital workers switch between applications roughly 1,200 times per day (losing ~4 hours weekly); 47% of digital workers struggle to find the information needed to complete their work. Large-scale “digital transformation” initiatives fail frequently—roughly 70% reportedly miss their goals. The cost associated with this friction is enormous: the software implementation/systems integration market alone was ~$380 billion in 2023.
This process—and its pain points—creates an opening for AI to transform how such software is implemented and used. The simplest way to understand this opportunity is to follow the system’s lifecycle: first you implement or migrate it; then you live in it daily; finally, as your business evolves, you build new things atop it. At each stage, the essence of the work is translating messy human intent into correct, auditable actions against the system of record.
Let’s examine how AI improves the use of legacy software systems at each stage.
Implementation Stage
Start with implementation—the highest-risk, most budget-sensitive, and clearest-return phase. Specifically: transforming chaotic requirements discovery (meetings, documents, tickets) into structured requirements—and automatically generating the implementation workflow: process and field mappings, configurations and code, test scripts, go-live cutover plans, migration handbooks—plus data cleansing and validation required for launch. Doing this well is hard: German supermarket giant Lidl spent $500 million before abandoning its SAP migration attempt.
Companies in this space are building copilots, project management tools, and other software to assist with migration and implementation. Below are examples of startups working in this area (a16z has invested in some of them):
Axiamatic is an AI “assurance” layer for ERP: it builds knowledge graphs from project artifacts, flags latent failures in requirements/change management via Slack/Teams, reducing S/4HANA project risk and accelerating delivery (partnered with SAP Build; embedded in KPMG/EY/IBM workflows).
Conduct is a copilot for code and process mapping—generating semantic layers and technical documentation for ECC→S/4 migrations, and supporting Q&A over custom tables/APIs to accelerate internal team takeover.
Auctor delivers agent-driven implementation delivery for systems integrators/professional services—automatically converting requirements discovery into structured requirements, and serving as the system of record for Statements of Work (SOW), design docs, user stories, configurations, and test plans.
Supersonik empowers channel partners/MSPs and customers with AI-powered product enablement—training visual and voice agents directly within real UIs, reducing pre-sales engineering needs and enabling channel-led implementation and scale.
Tessera is an AI-native systems integrator that manages enterprise transformation end-to-end—connecting to customers’ existing ERP instances, assessing implementation health, and flagging and auto-remediating items needing change during migration.
These companies create value by making transformations faster, cheaper, and lower-risk—across several dimensions: surfacing issues early in requirements and change management to prevent snowballing; compressing project timelines (a one-month delay can cost millions); converting chaotic project data into structured knowledge so internal teams can take over faster; and reducing reliance on large SI teams via automated mapping, documentation, testing, and enablement training.
We believe there’s ample room for more startups to build tools that collaborate with—not compete against—existing partners. Specifically:
Implementation agents that co-own outcomes and risk (covering requirement tracking, configuration comparison, cutover simulation, code generation, and drift detection)
Semantic documentation tools that keep knowledge up-to-date and accessible in real time
Enablement agents that turn training and channel rollout into reusable products
Because startups can alleviate enterprise-level burdens, they can price based on “value of avoided delays” and tap into transformation budgets CIOs and CFOs are already allocating—displacing bloated SI contracts in the process.
Usage & Maintenance Stage
Once the software suite is implemented, daily usage means navigating today’s chaotic UIs. Daily work spans dozens of interfaces; employee turnover constantly resets institutional muscle memory; and countless edge-case workflows never receive first-class treatment in the core product. Users spend excessive time hunting for fields, mirroring data across systems, or asking ops teams “Can you run this report for me?” The result: slow cycle times, avoidable errors, and persistent training overhead.
The AI opportunity lies in wrapping legacy systems with a friendlier, more capable “action system.”
Companies in this category build tools that help teams extract more value from systems they already use. In practice, this looks like a copilot living in Slack—or as a browser sidebar—that answers “Where is X?” or “How do I do Y?” via semantic search, and executes secure actions (e.g., creating tickets, posting journal entries, updating vendor terms) when APIs are available. These tools can also orchestrate cross-application composite workflows (“Pull last quarter’s purchase orders from SAP, check contract terms in Coupa, draft discrepancy notes in ServiceNow”), complete with human approval steps, audit trails, and fine-grained permission controls. The best tools also track adoption rates, time saved, and error rates.
In enterprises, much critical work isn’t cleanly exposed via APIs—it lives in UIs, thick clients, VDI sessions, and semi-documented admin consoles. That’s why modern “computer-use” agents are a vital complement to API-first copilots: they extend automation’s reach to the final 30–40% of workflows lacking reliable endpoints.
The core capability isn’t “clicking buttons”—it’s reliability amid chaos: sensing UIs, anchoring to stable elements, recovering from pop-ups and layout drift, and setting checkpoints to safely resume mid-process.
When combined with verification (diff checks, reconciliation, sandbox runs) and enterprise governance (SSO, key management, least privilege, auditing), this transforms previously manual tasks—ticket triage, month-end close steps, customer updates, pricing changes—into governed, reusable automations—even in parts of SAP/ServiceNow/Salesforce that vendors never built for automation. APIs make the smooth path fast; computer-use makes the long-tail workflows automatable.
Companies like Factor Labs and Sola have deployed such agents in production, replacing BPO spend and enabling large organizations to scale task automation.
Finally, even if you make SAP/ServiceNow/Salesforce easier to use, business keeps changing—meaning systems of record must evolve too. New products, new policies, new M&A, new regulations, and long-tail workflows too small to justify a core module all demand continuous software adaptation to match reality.
Historically, teams had only two options: customize the software (inheriting fragility), or build one-off apps (struggling with integration, governance, and maintenance). This is AI’s third entry point: rapidly delivering small, governed experiences atop systems of record—while keeping the core system clean.
Building new tools and automation atop legacy systems creates a “Lovable Layer” over “unloved software.” This pattern starts with a unified data-and-action plane: reading data from systems of record via APIs and events (supplemented, when necessary, by secure UI scraping), normalizing it into semantic models of business objects (orders, suppliers, tickets), and exposing a governed set of operations with permissions, approvals, and auditability.
Above this plane, teams deliver modern, scenario-specific experiences. Instead of forcing procurement analysts to navigate 12 SAP transaction codes to onboard a supplier, give them a single lightweight “Supplier Onboarding” app—collecting documents, checking for duplicates, routing approvals, and writing correct records back to SAP.
Instead of requiring RevOps to open five Salesforce screens to update renewal terms, give them a spreadsheet-speed editor supporting bulk edits, policy validation, impact previews, and fully audited submissions. Instead of launching another “portal project,” give frontline teams a command panel that answers questions and executes their daily cross-system operations (“Create return,” “Extend credit limit,” “Open P2 incident,” “Post accrual”)—no more tab-hopping across 20 browser windows.
These extensions also unlock cross-system workflows and automations—those no single vendor would prioritize: event-driven triggers like “If invoice posted and variance >3% → draft explanation → route for approval,” or “If ticket reopened twice → create issue record → assign owner → notify customer,” with human intervention checkpoints at critical nodes.
Over time, the most valuable deployments evolve into reusable “intent packages”—Quote-to-Cash, Supplier Onboarding, Month-End Close—not just encoding *what* to do, but *how* to do it safely in your environment.
Platforms like General Magic’s Cell make building foundational modules for such custom workflows accessible: upload an OpenAPI spec, and each endpoint becomes a callable operation; embed a native command bar with one line of script—this bar executes real API calls, backed by analytics, multi-tenancy, security guardrails, and permission controls. The focus thus shifts from “building yet another UI” to “orchestrating the right operations and policies atop systems you already trust.”
What Does the End State Look Like?
We believe legacy systems will persist—but they’ll no longer be the interface where work happens. ERP, CRM, and ITSM suites are too deeply embedded to be replaced on typical software cycles; they evolve slowly and will remain systems of record. What *will* change is the user-facing “action system” layered atop them: AI will become the default interface for discovering how systems work, executing cross-system workflows, and delivering modern, UI-bypassing experiences. In other words: bridges will become highways.
The enduring software in this category won’t resemble a chatbot—it’ll feel more like an operating system layer: a unified data-and-action plane with semantic models of business objects, plus guardrails that make AI trustworthy in production. As an end user, you’ll no longer need to learn which interface, which field, which transaction code to use (nor relearn everything each time the UI or process changes). You’ll simply describe your desired outcome—and the system will get you there.
The system will ask clarifying questions, show you a preview of what it will do, and execute with proper approvals and audit trails. The final closed loop looks like: “Create return and notify customer,” “Open P2 incident and pull last three related events,” or “Onboard this supplier, collect documents, route approvals, set payment terms”—operations that today require jumping between SAP, Salesforce, ServiceNow, and spreadsheets. This yields fewer errors and rework, less dependence on “tribal knowledge,” faster cycle times, and dramatically reduced training burden—because the interface is intent-driven, role-aware, and self-service by default.
The moat accumulates in real usage: every successful workflow becomes a reusable intent; every anomaly, a guardrail; every migration artifact, a living data lineage; every integration, a deeper map of how the enterprise truly operates. Over time, the “AI layer” becomes the destination where teams understand change impact, prevent drift, measure ROI, and deliver new workflows—even as underlying systems remain unchanged.
Join TechFlow official community to stay tuned
Telegram:https://t.me/TechFlowDaily
X (Twitter):https://x.com/TechFlowPost
X (Twitter) EN:https://x.com/BlockFlow_News
a16z
