ERP build vs buy: when to build with AI agents and when to buy a platform

Rémi Beges built custom ERPs for manufacturers before co-founding Bonx. Here he tests the build-or-buy question on 11 criteria and more than 140 published sources.

White paper

35 minute read

ERP build vs buy: when to build with AI agents and when to buy a platform

about the author

Remi Beges

Remi Beges

Co-founder & CTO

Remi holds a PhD in electrical engineering, specialized in semiconductors. He spent years automating workflows and building custom ERPs for manufacturers because nothing off the shelf was good enough, then co-founded Bonx so he could stop reinventing the wheel.

Introduction

This is an honest take on when it makes sense to build an ERP and when it makes sense to buy one.

Full disclosure: at Bonx, we sell an ERP platform, so we are biased. That said, we also write our own software with AI coding agents every day, and we ask ourselves the same question about our product. If agents can build software, why would a manufacturer buy ours?

That’s the central question this paper answers: should an industrial company build its ERP with AI coding agents, or buy an ERP platform and adapt it?

To decide between building and buying your ERP, we recommend looking at 11 criteria, shown in the table with the main considerations for each. The next section summarizes what the research found on each one and when buying or building makes more sense. The analysis that follows examines each criterion with published data, and the final section shows the consequences over time when a build gets it wrong.

CriterionConsiderations
Technical designWho decides the data model, the transactions, and how modules depend on each other
Business rulesMoney, dates, stock valuation, traceability, and repeated operations, written down and tested
SecurityServer-side access rules, secrets, dependencies, monitoring
PerformanceResponse time with years of data and peak users, background processing
Reliability & data safetyBackups out of the agents' reach and tested, limited permissions, release process, on-call
IntegrationsBehavior of each connection when a message is lost, repeated, or late
ComplianceE-invoicing, accounting export for tax audits, audit trail, retention, traceability
MaintenanceWho fixes and evolves the system, tests, documentation
CostModel cost per task, tooling, staff time
AdaptabilityHow specific processes are supported, and how safely
New capabilitiesWhat can be built with the models beyond a standard ERP, and by whom

The short answer: our conclusion on building vs. buying your ERP

After weighing all the research, here is the conclusion we came to. You can reach your own by working through the details in the rest of this paper.

The easy parts got easier, but the hard parts didn’t

If language models keep improving*, writing code becomes cheap, and the research reviewed below points to real progress in building new applications, in optimization, in security, and in conformance, wherever an official test suite exists.

However, it does not point to comparable progress in keeping a design coherent across years of changes, in applying unwritten business rules, in delivery stability and operations, in integrations, in compliance rules that have no official checker, or in the cost of using the best models.

Experienced teams get more out of AI

ERP vendors, including Bonx, don’t have a secret, better AI. They use the same models a manufacturer could use. That means AI alone doesn’t give a manufacturer an edge over a vendor, because the same tools are available to both.

That said, the largest study so far finds that experienced developers capture nearly all of the productivity gains from AI, so model progress tends to widen, not close, the gap between a team that has built and run ERPs for years and a company building its first one.

In other words, as AI improves, vendors with teams of experienced developers will tend to pull further ahead of a company building its first ERP, because experience, not access to the models, is what turns AI into a better product.

The bottom line: The bottom line is that building an ERP makes sense when the share of needs specific to the company approaches 80%. In the other cases, the option best supported by the data is to buy an adaptable platform and build the specific part on it with AI.

* Core assumption, limitations, and disclosures

The analysis assumes that large language models (LLMs) keep improving. They have improved quickly over the past 24 to 36 months, and the analysis assumes they keep doing so for the next 24 to 48 months.

GDPval measures this progress on real work. Professionals from 44 occupations, in the nine sectors that weigh most in the US economy (manufacturing among them) wrote tasks taken from their own jobs. Other professionals then compared, without knowing which was which, the deliverable produced by an AI with the one produced by a professional.

The best model's work was judged as good as or better than the professional's on 12% of tasks in May 2024, and on 85% in April 2026 (GDPval, OpenAI 2025, GPT-5.2, GPT-5.5). These figures should be read with caution: the last two are published by OpenAI on its own models and its own benchmark, and 220 of the tasks are public, so labs can train for them. The independent version run by Artificial Analysis uses AI judges instead of professionals, so its scores cannot be compared with these (GDPval-AA).

Line chart: share of tasks where the best AI model's work was judged as good as or better than a professional's, rising from 12% in May 2024 to 85% in April 2026.
GDPval, share of tasks where the best model's deliverable was judged as good as or better than a professional's, best published score at each date. The first two points come from the GDPval paper, the last two from OpenAI's announcements of its own models.

These tasks come with all the context they need and are done in one pass, which is the opposite of an ERP that evolves over years. The same paper also counts the time a professional needs to review the AI's work and redo it when it falls short. With that time included, a professional using the models tested in 2025 finished about as fast as one working alone, between 0.87 and 1.12 times the speed, against 90 to 327 times when the review is ignored.

The cost of a given level of intelligence falls fast. Answering a PhD-level science question as well as the best model of January 2025 cost $0.30 then and $0.0004 in mid-2026 (Epoch AI). This measure relies on a public benchmark that labs can train for, so part of the fall may come from models tuned to its questions rather than from cheaper intelligence. The best model of each date does not get cheaper in the same way: it cost about $0.04 per question in early 2024 and between $0.07 and $0.10 since August 2025, because each generation reasons for longer before answering (MIT FutureTech, Epoch AI). The Cost section looks at what this means for an ERP.

Line chart on a logarithmic scale: cost of answering one PhD-level science question. The cheapest model matching o3's January 2025 level falls from $0.30 to $0.0004, while the cost with the best-scoring model stays far higher.
Cost of answering one question of GPQA Diamond, a set of 198 PhD-level science questions. Its questions are public, so labs can train for them, which may make the green line fall faster than real capability (Epoch AI). The vertical scale is logarithmic: each gridline is 10 times the one below. Blue: the model with the best score at each date (MIT FutureTech data). Green: the cheapest model that answers as well as o3 did in January 2025 (Epoch AI).

To limit our bias, every claim below relies on published third-party data, linked in the text. Where the data goes against our position, it is reported as well.

Of course, even in doing that, this analysis has limits. Most measurements come from software benchmarks, not ERPs. Much of the 2026 evidence is in preprints. Surveys on integrations cover large companies. And ultimately it is written by an ERP vendor, which the exclusive use of third-party sources reduces but does not remove.

All 11 criteria, summarized

This summary covers the rest of the paper. For each of the 11 criteria, it shows what the research found, where it is heading, and when buying or building makes more sense. The sections that follow give the full analysis.

Technical design

Research: AI agents correctly extend an existing application about a third of the time, and in 39% of failures they break something that already worked.

Outlook, 2027 to 2030: Prototyping is solved. Keeping the design coherent across changes over time is still very weak.

Buy when: Nobody in the company is skilled enough to own the data model and the structure.

Build when: You have an experienced engineer to make the structural decisions and review the agents' work.

Business rules

Research: Over long sequences of accounting entries, the best agents produce an exact balance sheet at most 46% of the time.

Outlook, 2027 to 2030: Textbook rules are known. Long sequences and unwritten rules still fail.

Buy when: You have custom rules, but still need robust fundamentals on typical ERP topics such as stock and invoicing.

Build when: About 80% of your rules and workflows are unique to your business.

Security

Research: Only 37% of the working code from the best agent (September 2026) is also secure.

Outlook, 2027 to 2030: Fast progress, but attackers are using the same tools.

Buy when: Nobody can monitor, patch, and respond to security incidents.

Build when: Someone in the company has the hard skills to run security.

Keep reading

Just your work email to read the rest here: the full summary, all 11 criteria with the evidence, and the conclusion. Want the PDF too? Use the form on the side to unlock the paper and download it in one step.

Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.

Performance

Research: On real optimization tasks, the best agent reaches less than a quarter of an expert's speedup.

Outlook, 2027 to 2030: Strong progress when the goal is stated explicitly.

Buy when: Nobody has the skills to make the architecture decisions that performance depends on, and to monitor and maintain it.

Build when: Volumes stay modest (tables under 50,000 rows) and the business is not expected to grow, someone with baseline technical skills will watch performance, and you accept slower performance than a professionally built product. Traceability tables alone can pass 1 million rows within months.

Reliability & data safety

Research: Teams that adopted AI delivered less stably in 2024 and 2025.

Outlook, 2027 to 2030: No measured improvement.

Buy when: Nobody is skilled enough to manage backups and verify that they work, or losing data is unacceptable.

Build when: Someone you fully trust makes sure your data is safe, or you accept the risk of losing it overnight if an agent wipes everything.

Integrations

Research: Developers spend 39% of their time building new integrations.

Outlook, 2027 to 2030: Connectors are faster to write, but there are more systems to connect.

Buy when: The connections you need already exist on the platform.

Build when: The connections are truly unique to your business, such as niche domain-specific software or machines.

Compliance

Research: Agents come close to 100% when an official test suite checks the rule, and reach 44 to 76% when the rule exists only as text.

Outlook, 2027 to 2030: Progress where automatic checkers exist, but the rules change every year.

Buy when: The obligations are the common ones: e-invoicing, accounting export, and traceability.

Build when: The obligations are specific to your sector, and an expert turns them into checks.

Maintenance

Research: Maintenance consumes 40 to 80% of software costs over a system's life, a classic estimate that predates coding agents.

Outlook, 2027 to 2030: AI produces more code, and more copied code, to maintain.

Buy when: Nobody will know the code well enough to fix and change it for as long as the ERP is used.

Build when: The company keeps people who know the code and can fix and change it for as long as the ERP is used.

Cost

Research: A built system costs 1.7 to 5 times its build cost over its life, and one developer costs about $200,000 a year in the US.

Outlook, 2027 to 2030: Building gets cheaper, maintenance less so, and the best model costs more per task.

Buy when: You have few users compared with the team needed to build and maintain a system, and cash is better kept for the business.

Build when: You have many users and an engineering team already in place, and you prefer to own an asset and carry fixed staff costs.

Adaptability

Research: 38% of companies bent their processes to fit their ERP.

Outlook, 2027 to 2030: Adapting a platform keeps getting cheaper.

Buy when: The platform can be adapted on your own data without touching its core.

Build when: The platform can only be adapted by changing its core code, or about 80% of your needs are specific rather than 20%.

New capabilities

Research: Across 160,097 developers, the experienced ones captured nearly all of AI's productivity and exploration gains.

Outlook, 2027 to 2030: Everyone has the same models, but experienced teams get more out of them.

Buy when: You would spend your effort rebuilding standard functions.

Build when: You have an engineering and product team able to build what no platform offers.

Criterion 1: Technical design

Best case: A coherent design keeps the system fast and stable as it grows, and keeps each change cheap.

Worst case: A design decided by default, one request at a time, stays inconsistent. Fixes pile up on top of it without correcting it, and every change becomes slower and riskier.

Verdict

Today: Agents find the parts of a system but get the links between them wrong. They almost always manage to build a new application, and fail two times out of three when they keep changing an existing one, often breaking what already worked.

2027 to 2030: Agents will keep getting better at writing new code. The data does not yet show them keeping a design coherent through years of changes, which is what an ERP goes through. A company without technical staff that builds its ERP from scratch with agents will have its first screens within weeks. Each later request will then be handled on its own: a new table here, a copied rule there. After a year or two, changes will start breaking what already worked, and nobody in the company will be able to say why or to fix the structure. At this point, most likely the software will need to be scrapped, effectively netting out the investment (that at this point may amount to several millions of dollars, even with heavy AI usage and a limited in-house engineering team).

Evidence

The question here is what happens when a large language model (LLM), not an engineer, makes the structural decisions: the data model, the transaction boundaries, how modules depend on each other, etc.

  • Fred Brooks wrote that "conceptual integrity is the most important consideration in system design" (The Mythical Man-Month, ch. 4). David Parnas showed that changes made without understanding the original design degrade the structure until nobody understands the product (Software Aging, ICSE 1994).
  • In seven Apache projects, architecture flaws consumed 51 to 85% of maintenance effort. The five worst flaws covered 8 to 25% of error-prone files but took 20 to 61% of the effort, and their cost grew over time (Xiao et al., ICSE 2016).
  • Agents choose frameworks and infrastructure, and almost nobody reviews these choices as architecture decisions, and the wording of a prompt alone produced structurally different systems for the same task (Konrad et al., April 2026).
  • Asked to turn requirements into an architecture for 68 projects, models identified most components but scored at most 0.18 out of 1 on the links between them. About a third of their design choices had no basis in the requirements, and invented relationships were the most common error (R2ABench, 2026).
  • On 3,275 database normalization tasks, models repeatedly failed to infer the dependencies between data and to rebuild the constraints between tables (DNBench, September 2026).
  • Asked to rebuild 200 existing programs, from command-line tools to SQLite, no model fully succeeded on any of them in the original study. On the September 2026 leaderboard, the best model fully solves 4.5% of them and almost solves 37% (ProgramBench).
  • Building a new web application from a specification is close to solved: the best model reaches 92% on the current version of Vibe Code Bench, against 41% in February 2026, partly thanks to a revised benchmark (Vals.ai). Evolving an existing application through 10 successive change requests is not: the best score is 34%, and 39% of failures break something that already worked (VCB 1-100).
  • Architects interviewed and surveyed in 2026 use AI for mechanical tasks and rarely for decisions that depend on the project's context (Felder et al., FSE 2026).
  • On a benchmark where agents extend the same code base over many steps, structural erosion rose in 80% of runs and agent code was 2.2 times more verbose than human code. Better prompts raised the starting quality but not the rate of decay (SlopCodeBench, March 2026).
  • After adopting the Cursor AI editor, 806 open-source projects went faster for one to two months, then slowed down as their code became more complex and harder to work with (Carnegie Mellon, MSR 2026).
  • In the other direction, a study of 151 Java projects found no change in architecture problems after agent adoption, while code volume grew 12.8% (Larsen and Moghaddam, June 2026).

Most of the recent evidence comes from 2026 preprints, and one study finds no effect. The pattern is still consistent: models handle the local parts of a design well, and lose coherence on the relations between parts and over successive changes. An ERP lives for years through successive changes, which is the situation where agents score lowest. This matches 50 years of software engineering research, in which the quality of a system is set by its early structural decisions (Roychoudhury and Zeller, 2025).

Criterion 2: Business rules

Best case: Rules shared by every company are computed correctly everywhere: money, dates, stock valuation, traceability, etc.

Worst case: Small, silent errors that reach the books, the balance sheet, or the scope of a product recall.

Verdict

Today: Agents know the textbook rules, but they often get business rules wrong when nothing checks them: balance sheets exact at most 46% of the time over long sequences of entries, orders with negative quantities accepted, and code written instead of questions asked when a rule is missing.

2027 to 2030: Model progress will not supply rules that nobody wrote down. Errors trigger only where someone states the rules precisely and checks them automatically. A company without technical staff that builds its ERP from scratch will get screens that look right and figures that are slightly wrong: a rounding difference on each invoice, stock valued in two different ways, a user who can see margins they should not see. These errors stay silent until a year-end close, a tax audit, or a recall brings them to light.

Evidence

Some rules are universal. Amounts are computed in exact decimals and rounded at defined points. An operation repeated after a network error must not apply twice. Dates are stored with their time zone. Two simultaneous updates of the same stock must not overwrite each other. Every accounting entry balances. Stock is valued by one consistent method.

  • On 392 backend tasks, about half of the functionally correct programs could be exploited, and improper access control appeared in 22 to 51% of correct outputs depending on the task. A precise interface specification improved correctness by 7 to 9 points, while a generic security reminder barely changed anything (BaxBench, ICML 2025).
  • When five agents each built three applications, four of them accepted orders with negative quantities and three accepted negative prices, because the request did not forbid it (SecurityWeek, January 2026).
  • One study looked directly at money, dates, and repeated operations. In backend code written by five frontier models for 50 tasks without a specification, it counted 66 defects on money (floating point, rounding), 32 on repeated operations, 31 on dates, and 19 on access, and a 267-word specification cut them by 84%. It is the only study of its kind so far, it was written by a single author who also built the checking tools, and (disclaimer) it has not been peer-reviewed (Dhuri, September 2026).
  • Frontier models handle textbook double-entry accounting: Gemini 3 passed 16 of 16 checks and Claude Opus 4.5 passed 15/16 (Modern Treasury, January 2026, four scenarios, vendor test).
  • Over longer sequences, six models produced an exact balance sheet at most 46% of the time, with a gap of 26 to 41 points between their balance sheet and the one recomputed from their own journal entries (FinBalance, June 2026). On 160 expert accounting tasks, the best model scored 56.4%, and none exceeded 2.6% when required to succeed on the same task eight times in a row (APEX-Accounting, July 2026).
  • Unit tests cannot explore the order in which simultaneous operations run, so they pass flawed concurrent code (CONCUR, 2026).
  • When a requirement is missing, models write code instead of asking in more than 60% of cases (HumanEvalComm, ACM TOSEM 2025), and recent agents almost never ask unless told to (Ambig-SWE, ICLR 2026). Models guess an unwritten requirement correctly 41% of the time (Carnegie Mellon).

Frontier models know the textbook rules. They fail on long sequences, on simultaneous operations, and when the rule is not written down. Precise, checkable specifications help, generic reminders do not. Either way, someone has to know the rules and write them down.

Criterion 3: Security

Best case: Prices, margins, recipes, and customer data stay protected, and production keeps running.

Worst case: Data theft or ransomware. After the 2025 cyberattack on Jaguar Land Rover, production stopped for about five weeks, with a modeled cost of £1.9 billion for the UK economy (Cyber Monitoring Centre).

Verdict

Today: The best agent writes code that both works and is secure on about a third of tasks, and applications built this way already expose data and keys at scale.

2027 to 2030: At the current pace, agents will write secure code on most tasks before 2030. But attackers use the same models, and in 2025 flaws were already exploited before a fix existed. For a company without technical staff that builds its ERP from scratch, the main risk is that nobody watches the system once it runs: no monitoring, no patching, no plan when an attack happens. An exposed key or an outdated library can then stay open for months, until a data leak or a ransomware attack stops production.

Evidence

Chart of Endor Labs results from February to September 2026: share of AI-written code that works, split into code that is also secure and code that works but is vulnerable, for ten successive models.
Endor Labs, Agent Security League, Claude Code harness, 200 Python tasks, and 77 types of vulnerability. Dates are test dates in 2026.
  • On the Endor Labs benchmark, the share of code that both works and is secure rose from 6% to 37% between February and September 2026. With the best agent and model measured, 57% of working code is still vulnerable.
  • Veracode tests models without an agent. Its average stayed at 55% secure code in 2025 and 56% in 2026, while more than 95% of the code compiles. Adding security guidance to the prompt brought no statistically significant reduction in vulnerabilities (Kharma et al., May 2026).
  • A scan of 5,600 public applications built by code generation found more than 2,000 vulnerabilities, more than 400 exposed secrets, and 175 personal data exposures (Escape.tech, October 2025). Out of 1,645 Lovable applications, 170 let anyone read their data (CVE-2025-48757).
  • Commits made with Claude Code exposed secrets in 3.2% of cases, against 1.5% on average on GitHub (GitGuardian, 2026).
  • Attackers use the same models. In an espionage campaign described by Anthropic in November 2025, AI did 80 to 90% of the work. Mandiant measured that in 2025 vulnerabilities were exploited on average seven days before a patch existed.

Security of agent-written code is improving fast from a low base, but attack capability is improving at the same time.

Criterion 4: Performance

Best case: Screens and calculations stay fast as years of data accumulate: millions of stock movements, dozens of users at shift change, a material requirements run over the whole bill of materials, a scan that must answer instantly on the line.

Worst case: Slow screens on the shop floor and overnight runs that do not finish, discovered months after go-live.

Verdict

Today: Agents optimize code well when they are told to and given a measurable target. By default their code is less efficient than an expert's, they fail more often under database and architecture constraints, they write correct infrastructure code less than one time in five, and they rarely measure performance on their own.

2027 to 2030: Optimization on an explicit target is improving faster than any other measure here and should reach expert level. Nothing in the data shows agents setting those targets or making the infrastructure decisions by themselves. A company without technical staff that builds its ERP from scratch will get a system that runs well on test data. As years of stock movements accumulate, screens will slow down on the shop floor and overnight runs will stop finishing on time, and nobody will know whether the fix is an index, a work queue, or a new architecture.

Evidence

  • On 1,000 problems, code written by GPT-4 ran 3.12 times slower than the reference solution on average, and up to 13.9 times slower with 43.9 times more memory in the worst cases (EffiBench, NeurIPS 2024). Across six languages, the best model reached about 62% of expert efficiency (EffiBench-X, 2025).
  • On 498 real optimization tasks, Claude 4.5 Opus achieved 0.225 times the expert's speedup, against 0.024 for Claude 3.7 Sonnet (SWE-fficiency, ICML 2026). On GSO, solved optimization tasks rose from 3.8% in May 2025 to 88.2% in September 2026, partly because the test harness started telling agents to keep optimizing.
  • Code models generally fail non-functional requirements such as efficiency and robustness (NoFunEval, COLM 2024). Adding architecture and database constraints to a task cut the pass rate by 27 points on average, and database constraints hurt most (Constraint Decay, 2026).
  • Much of an ERP's performance is decided by technical choices at the infrastructure level, which no request to an agent mentions. Two examples follow. A long operation, such as a material requirements run over the whole bill of materials, can run in the background through a work queue, or block the screen until it finishes. A message between two systems can be delivered at most once and risk being lost, at least once and risk being applied twice, or effectively once through deduplication at the cost of more engineering (Kleppmann, Cambridge lecture notes). Agents are weak at this level.
    • The first benchmark of infrastructure code for AWS found GPT-4 correct 19.4% of the time, against 86.6% on ordinary Python tasks (IaC-Eval, NeurIPS 2024). Adding configuration knowledge raised success from 27% to 63%, but the match with what the user actually wanted stopped improving, which the authors sum up as models that code well but design poorly (Nekrasov et al., December 2025).
    • In a 2026 test, Terraform written by Claude Opus 4 passed the Checkov security scanner 23.1% of the time (SBSeg 2026). Writing non-functional requirements out in detail improves the code agents produce (Pereira and Garcia, August 2026), and 35.2% of generated code is less robust than human code, mostly through missing checks (Li et al., 2025).
  • Agent-written changes include a performance check less often than human ones, 45.7% against 63.6% (December 2025). No published study measures the behavior under load of a business application written by an agent.

Models improve strongly when performance is an explicit goal. When it is not, their code stays less efficient than an expert's, and infrastructure choices are made only if someone asks for them.

Criterion 5: Reliability & data safety

Best case: The ERP is up whenever the plant runs, and its history is intact.

Worst case: An outage stops shipping. Losing the stock movement history or the open order book means a company cannot invoice what it shipped, value its stock, or trace a lot during a recall. For small and mid-sized manufacturers, an hour of production downtime can cost up to $150,000 (Siemens, True Cost of Downtime 2024, measured on machine downtime).

Verdict

Today: Agents and automation have already destroyed production data, at Amazon-sized companies as well as small ones. Only data held out of their reach came back. Agents running systems solve about half of real incidents at best, and AI adoption still goes with less stable releases.

2027 to 2030: Agents will get more autonomy and more access, so a single wrong action will reach more data. Protection is a matter of setup: copies the agents cannot reach, delayed deletion, narrow permissions, and restores tested regularly. A company without technical staff that builds its ERP from scratch is likely to give the agent wide access so that it can work fast, and to keep its backups within reach of that same access, as in the PocketOS case. It may only discover a loss when it needs the data, for an invoice, a stock count, or a recall.

Evidence

  • In the DORA 2024 survey of about 3,000 professionals, each 25% increase in AI adoption was associated with 7.2% lower delivery stability. In DORA 2025, with nearly 5,000 respondents, the link with delivery speed turned positive while the link with stability stayed negative.
  • SWE-bench is a set of real bugs reported in popular open-source projects, where an AI fix counts as a success when the project's own tests pass (SWE-bench). When maintainers reviewed 296 agent fixes that passed those tests, about half would not have been accepted (METR, March 2026).
  • Running systems is harder still. Agents resolved 11.4% of site reliability scenarios in ITBench (ICML 2025). On 59 Kubernetes incidents, every model stayed below 50% at launch in May 2026 (ITBench-AA). On failures with compound or low-level causes, success fell to 15 to 28% (SREGym, NeurIPS 2026).

Agents and automation with access to production systems have already destroyed business data at scale:

Agents and automation with access to production systems have already destroyed business data at scale.

DateOrganizationWhat happenedData recovered
Oct 2026TV4The finished edit of a TV season was lost, and the premiere moved to 2027. Press sources say an AI agent with server access deleted it. TV4 denies that an autonomous agent did it and says the backup failed (Metro Mode)No
Apr 2026PocketOSA Cursor agent running Claude Opus 4.6 found an account-wide token and deleted the production database and its backups in about 9 seconds (Railway)Recovered by the hosting provider, which then added delayed deletion
Mar 2026Amazon retailOutages of the store, with about 120,000 and 6.3 million lost orders according to internal documents reported by the press, and an internal note citing AI-assisted changes. Amazon says one incident involved advice an agent took from an outdated wiki, and no AI-written code (Fortune, Amazon)Lost sales, not lost records. Senior sign-off now required on AI-assisted changes
Mar 2026MetaAn internal agent posted advice without approval, an employee acted on it, and company and user data was open to unauthorized engineers for about two hours, rated the second-highest severity level (TechCrunch)No misuse reported
Feb 2026DataTalks.ClubClaude Code ran an infrastructure teardown with an outdated configuration and deleted a production database holding 2.5 years of data and its visible snapshots (post-mortem)Restored after 24 hours from a hidden cloud snapshot
Dec 2025Amazon Web ServicesA service was down for 13 hours after the Kiro coding agent chose to delete and recreate its environment, according to the Financial Times (The Decoder). Amazon attributes it to misconfigured access controls and says one service in one region was affected (Amazon)No data loss reported, cause disputed
May 2024UniSuperAn automated process at Google Cloud deleted the private cloud of a pension fund with 647,000 members, in both regions (joint statement)Yes, after about two weeks, from backups held with another provider
Aug 2020KPMGA retention policy meant for one user was applied to the whole tenant and deleted the Teams chats of about 145,000 employees (The Register)No, according to an internal memo
Jan 2017GitLabAn engineer wiped the production database, and five backup methods all failed (post-mortem)Six hours of data lost for good

Several of the Amazon and TV4 accounts are disputed, and the table reports both sides. A study of 344 AI incidents relevant to companies found 188 where an autonomous system caused harm with no attacker involved, including 65 deletions of data or code (Cyera Research, May 2026). Restoring is not guaranteed either: among 900 organizations hit by an attack in 2024, only 10% recovered more than 90% of their data (Veeam 2025).

These losses happened at companies with experienced engineering teams, so buying does not remove the risk. A company without that expertise is more exposed, and may not even know it has lost data until it needs it. In every case where data came back, it came from a copy held out of reach of the system that failed, such as a hidden snapshot, a delayed deletion, or a backup at another provider.

Criterion 6: Integrations

Best case: Data entered once flows to accounting, customers, carriers, and machines.

Worst case: An invoice created twice, a dispatch advice sent twice, an ERP and an accounting system that silently disagree, and staff re-entering data by hand.

Verdict

Today: Writing a connector is easy for agents. The hard part is deciding what happens when a message is lost, repeated, or late, and applying that decision the same way everywhere, and none of it appears in a request.

2027 to 2030: The number of systems to connect keeps rising and each third party keeps changing its interface, so this design work grows rather than shrinks, whatever the models can write. A company without technical staff that builds its ERP from scratch will get each connection working on the first day. When the first failures arrive, such as a timeout during an invoice export or a carrier message received twice, it will find duplicates and mismatches between the ERP and the accounting system, with nobody able to say which side is right.

Evidence

Integration is a distributed systems problem, and its difficulties are well documented.

  • In 1994, Peter Deutsch listed the false assumptions that engineers make about networks, known as the fallacies of distributed computing. The first is the belief that the network is reliable, when in practice messages get lost (Rotem-Gal-Oz). When a system sends a request and gets no answer, it cannot know whether the request was processed.
  • No finite number of messages lets two systems be certain they agree. Real systems cope by making operations safe to repeat and by checking status afterwards (Kleppmann, Cambridge lecture notes). A message retried until acknowledged may be applied twice, the lecture's example being a £1,000 debit taken twice.
  • Stripe built idempotency keys so that a retried payment is not charged twice. The key must be checked against the original request and is kept for a limited time (Stripe, API documentation). Getting these mechanisms right takes engineering expertise: deciding what makes two requests identical, how long to remember them, and what to do when they differ. None of it appears in a request such as "connect us to our accounting software." Exactly-once delivery requires both systems to cooperate (Confluent, 2017).
  • For context, large companies run 957 applications on average, of which 27% are integrated (MuleSoft 2026), and their developers spent 39% of their time building new integrations in 2025 (MuleSoft 2025).
  • Integration and migration failures have measured costs. TSB's 2018 platform migration led to 225,492 complaints, £330.2 million of post-migration costs, and £48.65 million of fines (FCA final notice, TSB results). Revlon's 2018 ERP launch at one plant left about $64 million of net sales unshipped and caused $53.6 million of extra charges (Revlon 10-K). Neither failure involved AI. Both came from how the migration was planned, tested, and rolled out, which is engineering and project work rather than code writing, and faster code generation does not change it.

Generating a connector is easy. Deciding how every connection behaves when a message is lost, repeated, or late, and applying that decision the same way across all connections, is engineering work done before the code. The MuleSoft figures cover companies with more than 1,000 employees, not small manufacturers.

Criterion 7: Compliance

Best case: Invoices are accepted, tax audits pass, products can be traced.

Worst case: Rejected invoices, penalties, and recalls that cannot be scoped.

Verdict

Today: For most ERP obligations, such as the audit trail, the accounting export, traceability, retention, and quality holds, no automatic checker exists. Without one, agents are often wrong: 44 to 76% correct on rules written as text, against close to 100% when an official test suite exists.

2027 to 2030: Areas that come with official validators, such as e-invoice formats, will become reliable for agents (Vericoding, 2025 shows verified code rising from 68% to 96% in one year). The rest will not, and new obligations keep arriving. For example, e-invoicing for small and mid-sized French companies and battery passports in 2027, digital product passports from 2026. A company without technical staff that builds its ERP from scratch will have a system that looks compliant until a tax audit, a rejected invoice, or a recall shows otherwise. Each new obligation will mean reading the regulation again and turning it into checks, with nobody in the company who has done it before.

Evidence

An industrial company in Europe or the United States faces a growing list of obligations that its ERP must implement.

  • United States: since South Dakota v. Wayfair in 2018, the 45 states with a sales tax tax remote sellers above a sales threshold, so the ERP must compute tax by destination (Supreme Court). Records on export-controlled items are kept five years (ITAR, EAR). Defense suppliers holding controlled unclassified information must meet the 110 requirements of NIST SP 800-171 under the Cybersecurity Maturity Model Certification (CMMC), whose first phase started on November 10, 2025 (32 CFR 170).
  • Food in the US: the FSMA 204 rule requires a traceability lot code at each critical tracking event and a sortable electronic file within 24 hours of an FDA request, with enforcement from July 20, 2028 at the earliest (21 CFR 1.1455, Public Law 119-37).
  • Medical devices: since February 2, 2026, the FDA quality system regulation incorporates ISO 13485 and requires the unique device identifier to be recorded for each device or batch (FDA, 21 CFR 820.10). The software used in the quality system must itself be validated (21 CFR 11.10, FDA Computer Software Assurance).
  • Aerospace and defense: AS9100D requires configuration management, prevention of counterfeit parts, and traceability (IAQG), and US defense rules require tracking electronic parts back to their original manufacturer and quarantining suspect parts (DFARS 252.246-7007).
  • Automotive: IATF 16949 requires documented traceability plans that can identify and segregate suspect product within each carmaker's response times, on top of customer-specific requirements published for BMW, Ford, Renault, Stellantis, Volkswagen, and others (IATF).
  • Pharma: EU GMP Annex 11 requires validated systems, access control, and an audit trail recording the reason for each change, and asks for a formal quality process for custom or customized systems (Annex 11). Medicine packs carry a unique identifier with product code, serial number, batch, and expiry in the EU (Regulation 2016/161), and US law has required package-level electronic tracing since 2025 (FDA, DSCSA).
  • E-invoicing: every French company must be able to receive electronic invoices since September 1, 2026, and small and mid-sized companies must issue them from September 1, 2027 (impots.gouv.fr). The EN 16931 validation artifacts hold 223 business rules, plus about 759 rules specific to the UBL format and 587 to CII, revised about twice a year (CEN/TC 434). In Italy, where e-invoicing has been mandatory since 2019, 1.4% of 2.1 billion invoices were still rejected in 2021 (Corte dei conti).
  • Traceability: food businesses must identify their immediate supplier and customer for every lot (Regulation 178/2002, art. 18) and flag 14 allergen groups (Regulation 1169/2011). Pharmaceutical and medical device makers selling in the US need time-stamped audit trails that never hide previous values (21 CFR 11.10).
  • Tax audits: French companies must hand over their accounting entries as a file with 18 fields in a fixed order and continuous, chronological numbering (LPF art. A47 A-1), under penalty of €5,000 or 10% of the reassessed tax. Invoices must be linked to the underlying deliveries by a reliable audit trail (BOFiP).
  • Retention: accounting documents are kept for ten years (Code de commerce, art. L123-22), which overrides the GDPR right to erasure during that period and requires deletion afterwards.
  • New data obligations: a battery passport from February 18, 2027 (European Commission), and digital product passports for steel, textiles, tires, and aluminum from 2026 to 2027 (ESPR).

Whether agents implement a norm correctly depends on whether the norm comes with an automatic checker.

  • When a complete test suite or validator exists, agents now reach near-full conformance. A team of 16 Claude Opus 4.6 agents built a C compiler that passes 99% of standard compiler test suites, and its author notes that the result depends on a nearly perfect verifier (Anthropic, February 2026). An HTML5 parser ported with GPT-5.2 in about 4.5 hours passed 6,810 of 6,810 tokenizer tests (Willison, December 2025). Turning a clinical note into a FHIR health record, models scored at most 50% alone and up to 100% when they could call the official validator (Flexpa, 2025, 14 cases).
  • When the norm exists only as text, results are much lower. On 100 tax cases checked to the dollar, GPT-5 was right 76 times (Jurayj et al., 2026). On 6,232 rule-application tasks in tax, immigration, and housing law, the best result on the hard subset is 44% (DeonticBench, April 2026). Frontier models computed fewer than one third of US federal tax returns correctly even with every input provided (TaxCalcBench, 2025). The best model assigns the correct medical billing codes in 64% of cases (Vals.ai MedCode). None of five chatbots produced code compliant with the MISRA C++ safety standard despite explicit prompts (Umer, IEEE Access 2025).
  • Passing checks is not the same as being right. Formal verification proves that code matches the specification it is given, not that the specification reflects the law (Vericoding, 2025).

Part of an ERP's compliance comes with official validators, such as the EN 16931 rules for e-invoices, and that part is becoming achievable for agents, although no study has yet measured e-invoices generated by an agent. E-invoicing is also an integration/distributed systems problem: invoices travel through approved exchange platforms, with acknowledgments, rejections, and status updates to handle, so it combines both difficulties. Much of it has no test suite (e.g., a reliable audit trail, the meaning of an accounting export, lot traceability, or retention periods). There, someone has to turn the text into checks and keep them current as the rules change every year.

Criterion 8: Maintenance

Best case: The system evolves with the business.

Worst case: Most of the budget goes into keeping it running, and the knowledge of how it works is lost.

Verdict

Today: Code written with AI grows faster and contains more copies and more complexity, and people who learn through AI understand it less well.

2027 to 2030: Agents will take over more routine fixes. The data does not show the code becoming easier to understand, and understanding is what maintenance needs. A company without technical staff that builds its ERP from scratch will depend on the agent for every fix. Each fix adds code, often a copy of code that already exists elsewhere, and after a few years nobody in the company understands how the whole system works.

Evidence

  • Maintenance consumes 40 to 80% of software costs over a system's life (Robert Glass, Facts and Fallacies of Software Engineering, 2002, fact 41). Developers estimate spending 42% of their time on it (Stripe, 2018). These figures predate coding agents.
  • GitClear analyzed 623 million code changes. The share of changes that improve existing code fell from 21% in 2022 to 3.8% in 2026, while the share of copy-pasted code rose from 9.4% to 15.7% (GitClear 2026, vendor data that does not compare AI users with non-users). When the same code exists in several places, a bug fixed in one place often survives in the others.
  • Researchers compared 806 open-source projects that adopted the Cursor AI editor with 1,380 similar projects that did not. The adopters wrote much more code in the first month, then returned to their usual pace, while their code became more complex and drew more warnings from automatic quality checkers, and stayed that way (Carnegie Mellon, MSR 2026).
  • In a controlled study with 151 participants, code written with AI was not harder for other developers to modify later (Echoes of AI, 2026).
  • In a controlled trial with 52 mostly junior engineers, those who completed a coding task with AI scored 50% on a follow-up comprehension quiz, against 67% for those who coded by hand, with the largest gap on debugging questions (Anthropic, January 2026).

No study yet measures the share of maintenance in a system built by agents. The studies above show more code, more copied code, and more complexity after adoption in several datasets, no effect in one controlled experiment, and weaker debugging skills among people who rely on AI to learn.

Criterion 9: Cost

Best case: Building costs less than ever.

Worst case: Most of the cost comes after the build (e.g., maintenance, the people who review the agents' work, and model costs that grow with each generation of the best models).

Verdict

Today: Most of an ERP's cost is people: building it, then maintaining it for its whole life, which brings the total to 1.7 to 5 times the build cost. Model costs are a small part of it. The cheapest model that reaches a given benchmark score gets about 13 times cheaper every year, a figure inflated by models trained for those benchmarks, while each coding task done with the best model costs more than a year ago.

2027 to 2030: An ERP is built and maintained with the best model of its time, so its model costs follow the rising curve, on top of the people needed to review the work. A company without technical staff that builds its ERP from scratch will see a low build cost, then a running cost that grows with each new model and each fix, and that it bears alone. Which option costs less will depend mainly on the number of users and on whether an engineering team already exists: buying keeps cash for the business and costs per user, building ties up cash and staff but can cost less for many users.

Evidence

Over its life, the cost of an ERP is mostly people, and model costs are a small part of it.

  • Maintenance takes 40 to 80% of a system's lifetime cost (Glass, see Maintenance), so a built system costs 1.7 to 5 times its build cost over its life. Agents cut the build part the most, and the data shows the maintenance part falling less.
  • Building is paid mostly in salaries. The median software developer in the US earned $135,980 in May 2025 (BLS), and wages are 68.5% of what an employer pays for a full-time private-sector worker (BLS, June 2026), so one developer costs about $200,000 a year. At $13 per active day, an AI coding agent adds about $3,000 a year per developer.
  • Buying is paid mostly as a subscription per user, plus the cost of setting the platform up, which more than a quarter of companies exceed (Panorama Consulting, 2026).

The two options use cash differently. Buying needs little cash at the start and turns the ERP into a recurring cost per user. Building needs cash at once, in salaries during the build, then fixed salaries for as long as the system runs. Under IFRS, the development costs of internal software can be recorded as an asset once the project meets the conditions of IAS 38, while the configuration of subscription software is usually expensed as the work is done (IFRIC, 2021). US GAAP lets companies capitalize some implementation costs of cloud software (ASU 2018-15).

Which option costs less depends mainly on the number of users, because a subscription grows with users and a built system grows with the team. As an illustration, if one developer could build and maintain the ERP alone, the yearly subscription would cost as much as that developer at about 330 users for $50 per user per month, 170 users at $100 and 80 users at $200. The illustration leaves out the cost of setting up a platform on one side, and the likelihood that one developer is not enough on the other.

Line chart on a logarithmic scale: cost of one coding task with the best model at each date, which rises, against cost of one science question at fixed quality, which falls.
The blue line is what one coding task costs with the best model available at each date (MIT FutureTech data on SWE-bench Verified). The green line is what one science question costs at a fixed quality level, the level of the best model of January 2025 (Epoch AI), measured on a public benchmark that labs can train for. The vertical scale is logarithmic: each gridline is 10 times the one below.

Model costs come on top, and they follow two trends at the same time.

  • The price of a given capability level falls by about 47% per quarter, or about 13 times per year (Epoch AI, September 2026).
    • Answering a science question at o3's level cost $0.30 in January 2025 and $0.0004 in mid-2026. This figure is exposed to benchmaxxing, and its authors say so. It tracks the cheapest model that reaches a given score on benchmarks, and labs may train their models for some of these benchmarks: on the only one whose content is kept secret, the price falls more slowly.
    • The cheapest model to reach a score is rarely a frontier model, and when a public math test was rewritten with new questions of the same difficulty, several families of models showed systematic overfitting while frontier models showed little (GSM1k, 2024). The calculation also assumes a user who switches to the cheapest model every quarter. The figure shows that a benchmark score gets cheaper, not that the same work does.
  • The cost of using the best available model rises on coding tasks, because each generation uses many more tokens per task. One run of SWE-bench Verified with the best model cost $88 in October 2024 and $2,323 in February 2026 (MIT FutureTech, data). The output of reasoning models grows about five times longer each year (Epoch AI). On science questions, the best model's cost peaked in December 2024 and has stayed around $0.07 to $0.10 per question since.
Chart indexed to 100 for Claude Opus 4.8: price per token falls 20%, tokens used fall 50%, and the cost of running the same test rises 27% by Opus 5.5.
Successive Claude Opus models in 2026, indexed to 100 for Opus 4.8: cost of running the same test (Artificial Analysis Intelligence Index v4.3.2 at maximum effort), price per output token, and tokens used for that test.

Between Claude Opus 4.8 and Opus 5.5, the price per token fell 20%, the tokens used rose 50%, and the cost of the same test rose 27% (Artificial Analysis). Anthropic estimates the cost of Claude Code at about $13 per developer per active day (Claude Code).

Model progress makes yesterday's benchmark scores cheap and frontier intelligence more expensive per task. The second trend is the more robust of the two, because it measures what the models consume rather than how well they score. An ERP needs the most reliable model available, because its errors are expensive.

Criterion 10: Adaptability

Best case: The software supports the company's own processes instead of forcing generic ones.

Worst case: Processes bent to the software, or changes to a shared core that break other functions or expose data.

Verdict

Today: A built ERP fits the company exactly. Platforms differ: some adapt only through code in their core, which has to be redone at each upgrade, while others (like Bonx) allow adaptations on the company's data that survive upgrades.

2027 to 2030: AI makes adaptation cheaper on both sides, which narrows the gap for platforms designed to be adapted safely. A company without technical staff that builds its ERP from scratch gets a system that fits its processes exactly on the first day. Whether it still fits five years later depends on the other criteria: a design that can change, rules that stay correct, and someone able to maintain it.

Evidence

  • In a 2013 survey of ERP users, 38% had changed their processes to fit the software and 29% had modified the software to keep their processes (Panorama 2013).
  • No published study measures the share of a company's needs covered by standard ERP functions. The often quoted figure of 70% has no traceable source.
  • Odoo, a widely used open-source ERP, can be adapted in two ways:
    • Odoo Studio adds fields, views, models, automations, and reports without code (Odoo Studio).
    • Beyond that, adaptations are Python modules that extend the core.
    • Odoo releases one major version a year and requires an upgrade at least every two years, and the maintainer of each custom module must make it compatible with the new version, unless the customer pays Odoo a monthly fee per 100 lines of custom code to do it (Odoo upgrade documentation, Odoo Enterprise agreement).

A built ERP fits the company by construction, which is its main advantage. On a platform, adaptability depends on mechanisms that let a company add its own fields, tables, screens, and rules on its data without touching the shared core, with permissions and isolation so that an adaptation cannot break other functions or expose data.

AI lowers the cost of building these adaptations. Their safety comes from the platform's mechanisms, not from the model. The way adaptations are made also sets their long-term cost. When they are code inside the platform's core, each one becomes work at every upgrade, as Odoo's terms show. When they are made on the company's data through mechanisms the platform maintains, they survive upgrades without being rewritten.

Criterion 11: New capabilities

Best case: Software that does part of the work instead of only recording it. For example, plans that rebuild themselves when an order changes, supplier documents read and entered without typing, routine back-office tasks carried out without a person, etc.

Worst case: A company that builds alone reaches, at best, what its own team can imagine and verify, which usually means rebuilding a standard ERP while others move ahead.

Verdict

Today: Experienced engineers capture nearly all of the productivity and exploration gains from AI, and judging what AI produces takes expertise. In manufacturing, AI has paid off after a dip, and only with the organizational work around it.

2027 to 2030: Everyone will have the same models, and the gap will come from what is built with them. Two comparable manufacturers show what this means. This is a scenario built from the data in this analysis, not a measurement.

Evidence

Builds with agents, no engineering teamBuys an adaptable platform
First monthsFirst screens within weeks, since agents almost always build a new applicationStarts from functions already used and tested by other manufacturers, through a setup project. More than a quarter of these projects run over budget, so the setup deserves the same care as a build
Years 1 to 2Each change risks breaking what worked (34% success when evolving an application, 39% of failures break something). Effort goes into fixesAdapts the platform to its own processes without touching the core. Fixes, security patches, and new regulations come from the vendor, along with new capabilities built by a team that uses the same models with more leverage
Year 5Maintenance takes most of the budget (40 to 80%). The system does what the company knew how to specify in year 1The ERP has kept improving without the company building or maintaining it, and its own team spends its time on its processes. The company depends on the vendor for upgrades, prices, and support, which makes the choice of vendor the main decision

The comparison turns the other way when the company that builds has its own engineering and product team, or when about 80% of its needs are specific: it can then build capabilities no platform offers, and they become its own advantage.

Projection: The gap is largest if the platform is truly AI-native, with an AI that carries out most of the back-office work on its own. No published study has measured this in a real ERP yet, so the projection below rests on an assumption: the ERP's AI does 80% of the back-office work, and its own checks replace most of the human review. The assumption is strong. With the models of 2025, reviewing and redoing the AI's work canceled most of the time saved (GDPval, see Main assumption).

In US manufacturing, business and financial staff and office and administrative staff made up 12.6% of employees and earned $90 billion in wages in 2021 (BLS), against $6.1 trillion of shipments (Census), or about $500,000 per employee. With employer costs, the back office costs about 2% of revenue.

Take a manufacturer with 100 employees, $50 million of revenue and an 8% operating margin, within the range of listed US manufacturers, from 4% in steel to 16% in machinery (Damodaran, January 2026). Its back office has about 13 people and costs about $1.1 million a year. The company that builds is assumed to pay one developer and not to reach the same automation, because its effort goes into standard functions. The company that buys is assumed to pay $100 per user per month for 30 users.

Builds from scratchBuys an AI-native ERP
Back-office costAbout $1.1 millionAbout $200,000, the equivalent of 10 people redeployed or not replaced
ERP costAbout $200,000 for one developerAbout $36,000 of subscription
Operating profitAbout $3.8 millionAbout $4.8 million
Operating marginAbout 7.6%About 9.7%

Under these assumptions, the company that buys earns about a quarter more operating profit each year than the one that builds, and about 55% more if both start from a 4% margin. The projection leaves out setup costs on both sides and any effect on revenue, such as faster quotes or fewer late deliveries, which no study has measured yet. The industrial data in the evidence below also suggests that the gains arrive after an adjustment period.

Everyone has access to the same models. What differs is what is built with them, and by whom.

  • Across 160,097 developers on GitHub, AI writes about 29% of Python functions in the US. Programmers who use AI also expand more readily into new domains of software, and experienced programmers capture nearly all of these productivity and exploration gains, while early-career developers show no significant benefit (Daniotti et al., Science 2026).
  • Earlier controlled trials on routine tasks point the other way. At Microsoft, Accenture, and a Fortune 100 company, less experienced developers adopted Copilot more and gained more, although the difference was not statistically significant (Cui, Demirer et al.). In customer support, novices gained 34% against 14% on average (Brynjolfsson et al., NBER 2023).
  • Judging AI output takes expertise. Maintainers would reject about half of the agent fixes that pass automated tests (METR, March 2026), and fixing an agent's change took 26 to 42 minutes on average (METR, August 2025). Changes submitted by less experienced developers working with AI drew 4.52 times more review comments and were accepted 31% less often (study of 22,953 pull requests, 2026).
  • In US manufacturing, plants that adopted industrial AI first lost productivity, with more work in progress, investment in robots, and staff cuts, then grew faster than others. The losses were concentrated in older firms and reduced by growth-oriented strategies (McElheran, Yang, Kroff and Brynjolfsson, working paper, 2025). AI changes how a plant performs only with the organizational work around it.
  • The 2025 DORA report describes AI as an amplifier of an organization's existing strengths and weaknesses (DORA 2025).

The evidence splits by what is measured. Novices gain more on short routine tasks, while experts gain more on real work, explore further and are the ones able to verify the result. Building capabilities that did not exist before is that kind of work.

What happens over time if you build

If you decide to build, the table below shows how the picture typically changes, from the first months to year 5. It is a map of the trade-offs to expect, and of the problems worth designing around before they appear.

CriterionFirst monthsAfter 1 to 2 yearsAfter 5 years
Technical designFeatures ship fastEach change gets slower and riskierPartial or full rewrite
Business rulesSmall errors in totals and stockWrong margins and stock values in the booksWrong financial statements, recalls that cannot be scoped
SecurityExposed data or keysIntrusion or ransomwareProduction stopped for weeks after one incident
PerformanceFast on test dataSlow screens, overnight jobs that overrunRe-architecture
Reliability & data safetyOutages during releasesA data loss incidentGaps in the stock and order history
IntegrationsManual re-entry, duplicatesSilent mismatches with accounting and customersEach new connection costs as much as the first
ComplianceRejected invoicesPenalties at a tax auditNew obligations left unimplemented
MaintenanceFew issuesMost effort spent on fixesA system nobody understands
CostLow build costRunning cost overtakes build costMost of the lifetime cost is running cost
AdaptabilityWorkarounds in spreadsheetsProcesses bent to the softwareSoftware bypassed or abandoned
New capabilitiesStandard functions rebuilt one by oneNo capability beyond what was specifiedBehind competitors whose ERP kept improving

Where this leaves you

The models will keep making code cheaper. What they do not replace is the experience of running an ERP over years: keeping the design coherent, getting the business rules right, and keeping the system running. So the question is less whether AI can write your ERP than who will own it, test it, and evolve it once it exists.

What to take away

  • AI makes the easy parts easier, not the hardest ones: a coherent design over years of change, unwritten business rules, operations, integrations, and compliance.
  • Experienced teams get more out of AI, so the gap between a team that has run ERPs for years and a company building its first one tends to widen.
  • Building makes sense when most of your needs are specific to your company. In the other cases, buy an adaptable platform and build the specific part on it.
  • Use the 11 criteria above to see where you stand, and plan for the problems the table shows before they appear.

Buy the platform. Build the part that’s yours.

For most manufacturers, the research points to one answer: buy an adaptable platform, and build the specific part on it with AI. Bonx is the AI-native manufacturing ERP, designed for exactly that.

It adapts to your plant, not the other way around

Your managers change the data model, processes, automations, AI agents, and screens with no code and no consultant. About 90% of operations run on standard modules. The rest is built as an app inside Bonx, tested in draft, and published when you decide.

“Bonx adapted to our system, not the other way around.” David Nicolas, Féroce

It deploys in weeks, not years

A first go-live in 10 weeks on average, and a full go-live in 4 to 6 months, against 12 to 24 months for legacy ERP. Féroce went live in 42 days without interrupting operations. How Bonx deploys so much faster than legacy ERP

It fits the stack you already have

One system for orders, inventory, purchasing, planning, production, quality, logistics, and invoicing, connected to your CRM, e-commerce, and accounting tools. Nervures cut manual data re-entry by 95% across production and logistics.

See your hardest process in Bonx

Bring the process you were thinking of building. We’ll show you how it would run in Bonx, and where building on top still makes sense. Not sure where your company falls? We’re happy to walk through the 11 criteria with you.

Request a demo

Unlock the full paper and get the PDF

Thanks! Your PDF is ready.

Download the PDF
Read everything online, and keep the PDF to share with your team.