Skip to content

Enterprise IT

Article originally published on HSN Labs. Author: Hugo Nascimento.

The Death of Tier-1 Support: Why ERP Consultancies and IT Helpdesks Cannot Defend the Billable Hour

Reading time: 4 minutes. Author: Hugo Nascimento.

Context: I wrote this after auditing an IT helpdesk ticketing log where routine master data fixes in Totvs and SAP took forty-eight hours to resolve, while external consultancies billed hundred-dollar hourly rates for simple configuration changes. The billable hour model for Tier-1 support is dead.

The enterprise IT sustaining model is built on an extractive economic racket: selling expensive human billable hours for trivial, deterministic procedural work.

Every month, mid-market and enterprise companies pay multi-thousand-dollar retainers to systems integrators and consulting firms to maintain installations of SAP, Oracle, and Totvs Protheus.

When an internal accounting clerk encounters an error because a vendor CFOP tax code is missing or an inventory batch failed, what happens?

The clerk files a ticket. The ticket sits in a queue for twenty-four hours. A junior consultant opens the ERP, cross-references a standard configuration table, enters the missing code, clicks save, and bills two hours on the client monthly statement.

There is zero intellectual creativity or strategic thinking in that workflow. It is pure mechanical rote work, and defending it as human labor is no longer viable.

The Two Extractive Pillars of Enterprise Support

The traditional enterprise IT support industry relies on operational inertia across two massive cost centers:

1. The ERP Sustaining Retainer Illusion

Enterprise leaders are conditioned to believe that maintaining an ERP requires a continuous army of external consultants.

When you audit these retainers, over seventy percent of the logged hours do not involve complex system upgrades or custom architecture. They consist of mundane master data maintenance: fixing address formats, updating tax withholding codes, re-routing rejected approval workflows, and reconciling stuck batch jobs.

When a deterministic agent is connected directly to ERP APIs and error logs, it detects the missing master data parameter, validates the entry against the corporate business ontology, and commits the fix in two hundred milliseconds. The entire justification for fifty-thousand-dollar monthly sustaining retainers evaporates.

2. The Internal Helpdesk Triage Queue

The same mechanical waste plagues internal IT service management: * Unlocking Active Directory accounts and resetting multi-factor authentication tokens. * Provisioning standardized email group memberships and role-based access permissions. * Diagnosing recurring VPN handshake failures and local network configuration errors. * Parsing application server crash logs to match known error codes.

Helpdesk technicians spend their days acting as manual switches between user chat messages and administrative web consoles. Deterministic agents connected via authenticated Model Context Protocol endpoints execute these routine procedures instantly, eliminating ticket queues and cutting resolution times from days to seconds.

Shifting from Ticket Triage to Autonomous Self-Healing

The goal of modern enterprise architecture is not to make human technicians close tickets ten percent faster. The goal is to eliminate the concept of the support ticket entirely.

When deterministic agents monitor system telemetry and operational exceptions in real time, they resolve root causes autonomously before an employee even notices an error.

The billable hour consulting firm wants systems to break so they can bill hours to fix them. The enterprise needs systems that repair themselves. Autonomous agents make that economic alignment possible.

Article originally published on HSN Labs. Author: Hugo Nascimento.

Legacy Core Systems Will Not Die: They Are the Engine Behind Autonomous Agents

Reading time: 4 minutes. Author: Hugo Nascimento.

Context: I wrote this reflection after reading a Gartner analysis on enterprise modernization timelines projecting fifteen-year mainframe rewrite horizons. Ripping out legacy core systems is financial suicide; turning them into headless engines for autonomous agents is the pragmatic strategy.

The prevailing consulting narrative that artificial intelligence will replace legacy enterprise core systems is completely wrong.

Every year, global systems integrators convince Fortune 500 boards to greenlight multi-hundred-million-dollar modernization programs. The pitch is always the same: rip out that thirty-year-old COBOL mainframe, that vintage SAP ECC deployment, or that on-premise Totvs Protheus instance, and replace it with a modern cloud microservices architecture.

These projects routinely drag on for seven to ten years, run three hundred percent over budget, and often get canceled after burning hundreds of millions of dollars without processing a single live transaction.

Legacy systems are not operational liabilities. They are the battle-hardened, transaction-tested foundation of the global economy.

The Hidden Value Locked in Legacy Systems

An enterprise core system that has run continuously for three decades contains something irreplaceable: thirty years of codified corporate wisdom.

Every obscure edge case, every union agreement exception, every quirky regional tax rule, and every supplier rebate calculation has been patched and tested in that codebase over decades.

Attempting to rewrite this accumulated logic from scratch introduces existential operational risk:

1. The Lost Documentation Reality

The engineers who wrote the original COBOL routines, stored procedures, or custom ABAP modules retired fifteen years ago. The code itself is the only living documentation of how the enterprise actually functions. Attempting to reverse-engineer thousands of undocumented edge cases into new microservices guarantees critical regressions.

2. Unrivaled Transactional Integrity

Modern distributed databases struggle to match the raw transactional consistency of mature relational and mainframe engines. A banking mainframe processes millions of concurrent financial transactions every day without dropping a single balance or corrupting double-entry ledgers.

3. The Real Problem Is Interface Friction

The bottleneck in legacy enterprise systems was never the underlying transactional engine. The bottleneck was the human interface.

Enterprise employees spend thousands of hours transcribing data from customer emails, PDF purchase orders, and Excel sheets into clunky terminal emulators and antiquated green-screen forms. The system worked fine; the human data bridge was slow and expensive.

The Agentic Solution: Wrapping Without Ripping

The winning enterprise architecture does not rip out legacy core systems. It decouples the core transactional engine from human interfaces:

1. Reverse-Engineering Business Ontologies

Instead of rewriting legacy code, our Forward Deployed Engineers inspect database tables, transaction logs, and data dictionaries. We codify business invariants, state transition rules, and validation logic into an executable knowledge graph.

2. Headless Agent Execution

Autonomous agents become the new operational interface. The agent ingests unstructured inbound purchase orders, parses customer requests, validates parameters against the business ontology, and commits transactions directly via legacy APIs, message queues, or headless terminal emulators.

3. Preserving Core Transactional Truth

The legacy database remains the single source of truth. Transactional commits, financial ledgers, and compliance audit logs remain completely intact. The enterprise gains the speed, cost reduction, and twenty-four-hour execution of autonomous agents without taking on the catastrophic risk of a core system replacement.

Do not burn capital rewriting systems that already work. Turn your legacy core into the headless backing engine for autonomous agents.

Article originally published on HSN Labs. Author: Hugo Nascimento.

The Cost of Non-Deterministic AI in Legacy IT

Reading time: 3 minutes. Author: Hugo Nascimento.

Context: During an architecture audit for a mid-market financial firm, I found them spending forty thousand dollars monthly on human quality assurance just to verify database writes from an experimental AI assistant. The automation was costing more than the manual process it replaced.

Enterprises do not run on probabilities. They run on deterministic guarantees.

Systems like SAP, Oracle, AS/400 mainframes, and core PostgreSQL databases were built with zero tolerance for stochastic variance. In a banking ledger or an inventory balance, an entry is either mathematically valid or the transaction is aborted.

When enterprise teams attempt to force probabilistic language models into these rigid environments without an architectural translation layer, they do not create operational efficiency. They create massive, unquantified financial waste.

The Three Hidden Costs of Probabilistic Automation

1. The Manual Verification Tax

The moment an engineering team realizes that a language model has a three percent error rate on database writes, fear takes over.

To prevent corrupted records, the company hires temporary analysts or reassigns senior developers to inspect every single transaction output before it commits. In the audit I conducted last year, the client was spending forty thousand dollars a month on human verification to support an AI tool that was supposed to save twenty thousand dollars in labor. The automation was a net negative on the company P&L.

2. Audit Exposure and Regulatory Penalties

In regulated sectors like financial services, insurance, and healthcare, every record modification must be defensible to external compliance inspectors.

When an auditor demands to know why a loan status was changed or why an insurance discount was applied, presenting a probabilistic prompt context window is an immediate compliance violation. Regulators require deterministic, immutable rule trails. If your software cannot explain its decision path through deterministic logs, your enterprise faces massive regulatory fines.

3. Permanent Sandbox Confinement

Hundreds of enterprise AI projects remain trapped in internal sandbox environments for over a year. The Chief Information Officer and the security committee refuse to grant production write access to core databases because the catastrophic risk of database corruption vastly outweighs any productivity gains shown in sandbox demos. The company burns its innovation budget on vaporware.

The Solution: Architectural Decoupling

To deploy agents into legacy corporate environments safely, you must decouple probabilistic intent from deterministic execution:

  • The Reasoning Engine Proposes: The language model parses unstructured customer emails, PDF documents, and natural language requests, proposing a structured intent payload.
  • The Ontology Layer Validates: An executable business ontology checks whether the proposed action complies with corporate rules, temporal bounds, and relational invariants.
  • The Deterministic Worker Commits: If and only if all validation guards pass, a deterministic software worker executes the transaction through existing, secure enterprise APIs or database protocols.

Predictability is the prerequisite for enterprise production access. If your architecture cannot guarantee determinism, it will never leave the sandbox.

Article originally published on HSN Labs. Author: Hugo Nascimento.