Hugo Nascimento

LATAM Airlines: Deterministic Agents in a 3% Margin Business

hugo — Sun, 13 Sep 2026 00:00:00 +0000

LATAM Airlines: Deterministic Agents in a 3% Margin Business

Airlines run on 3% margins. 31% of their operating cost is jet fuel. There is no slack.

If an AI agent does not create immediate value or cut costs, it dies.

I analyzed LATAM Airlines' deployment of customer experience agents in production. They process millions of interactions. They learned three hard lessons about agentic engineering at scale.

1. Semantic Decentralization Burns Money

LATAM initially built specialist agents (flights, hotels, insurance). Each agent reasoned and generated final structured outputs.

Result: 15% overhead in token consumption and latency.

Fix: Strict Supervisor pattern. Specialist agents became blind tool executors. The Supervisor node handles all final semantic formatting.

Takeaway: Do not ask every node in your graph to reason about output structure. Centralize formatting. Cut costs by 15% without losing quality.

2. Telemetry Beats Prompt Hacking

In production, 13% of user interactions failed routing. The system flagged them as "out of scope."

Amateurs add prompt penalties to stop hallucinations. LATAM looked at LangSmith telemetry.

Data showed 95% of those failed queries were legitimate passenger needs (baggage, check-in). The model didn't fail. The architecture didn't fail. The business logic was simply incomplete.

Fix: Added a dedicated Customer Care node. Routing errors dropped to 1%.

Takeaway: Observe production telemetry. Build deterministic nodes for reality, not for your happy path.

3. The Chatbot Is Not The Product

This is my core thesis.

A B2C chatbot is just a data collection interface. Conversations are cheap. Structured signals are valuable.

LATAM realized this. They built Compass: an internal engine that takes unstructured chat logs, applies strict semantic ontologies, and outputs a Knowledge Graph directly into BigQuery.

When a passenger asks about "Italian restaurants near the hotel," they aren't just chatting. They are feeding a deterministic pipeline with semantic preferences.

Stop building free-text wrappers. Use AI as a ruthless parser to turn noise into structured production data.

That is how you replace legacy IT. That is how you expand margins. That is how you prove ROI to a CFO.

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

The Cost of Non-Deterministic AI in Legacy IT

hugo — Thu, 10 Sep 2026 00:00:00 +0000

The Cost of Non-Deterministic AI in Legacy IT

Enterprises run on deterministic systems: SAP, Oracle, AS400 mainframes, and core transactional databases. These platforms were built with zero tolerance for probabilistic variance.

Introducing non-deterministic AI into these environments without a translation layer creates massive hidden expenses.

The Three Hidden Costs

1. Endless Manual QA

Teams spend more engineering hours monitoring model outputs and verifying database writes than the original manual workflow required. The software becomes a cost center rather than a leverage point.

2. Unquantified Regulatory and Audit Exposure

In regulated industries such as banking and healthcare, every record modification must be defensible to external auditors. Probabilistic models cannot explain why a specific action was chosen unless deterministic reasoning paths are recorded.

3. Permanent Sandbox Confinement

Initiatives remain stuck in proof-of-concept sandboxes for twelve months. Corporate IT security teams rightly refuse to grant write access to core systems because the risk of database corruption exceeds any productivity gain.

The Solution: Architectural Decoupling

To unlock production value, decoupling is mandatory: - The reasoning engine proposes actions based on context. - The deterministic ontology layer validates whether the proposal complies with corporate invariants. - The execution layer applies verified mutations through standard enterprise APIs.

Predictability is the prerequisite for enterprise production access.

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

Chatbot vs Agent: Why Replacing BPOs Requires Deterministic Guardrails

hugo — Tue, 08 Sep 2026 00:00:00 +0000

Chatbot vs Agent: Why Replacing BPOs Requires Deterministic Guardrails

A chatbot answers text questions. An agent executes multi-step workflows and mutates state in core enterprise systems.

Treating conversational chatbots as enterprise agents is the most common reason corporate automation initiatives fail to generate financial returns.

The BPO Replacement Challenge

If your strategic objective is to terminate a multi-million dollar third-party BPO contract, conversational answers are useless. You need an autonomous digital workforce that can: - Reconcile incoming invoices against ERP purchase orders. - Validate inventory allocations across multiple warehouse databases. - Resolve customer billing disputes according to strict contract terms. - Commit financial ledger changes with verifiable audit trails.

The Human in the Loop Trap

When probabilistic models lack deterministic constraints, engineering teams get terrified of hallucinations. Their default reaction is adding human verification steps to every action.

This creates human-in-the-loop purgatory. If every AI decision requires human oversight, labor costs remain identical and latency skyrockets. The financial ROI of replacing the BPO evaporates completely.

The Deterministic Fix

To achieve true autonomy, agents must operate inside mathematically bounded guardrails: 1. Strict State Machines: The agent can only select actions allowed by current system state. 2. Hard Schema Validation: Payloads are validated against strict JSON schemas before reaching production APIs. 3. Automated Evaluation Gates: Decisions are tested against historical ground truth before write permissions are granted.

Autonomy is not created by better prompts. Autonomy is created by deterministic architecture.

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

The Integration Drift: When Prompts Break Production

hugo — Sat, 05 Sep 2026 00:00:00 +0000

The Integration Drift: When Prompts Break Production

Large language models are stochastic reasoning engines. Enterprise APIs are rigid, deterministic protocols.

Connecting an unconstrained model directly to an enterprise database creates an architectural failure point known as integration drift.

How Integration Drift Occurs

A natural language prompt produces valid JSON payloads during initial development testing. Two weeks later, a minor change in user input phrasing or an upstream model weights update causes subtle structural changes: - An integer field returns as a string. - A mandatory database key is omitted. - An enum value is substituted with a near synonym.

The downstream ERP receives an unparseable payload. Transactions halt, batch jobs fail, and manual intervention is required to unlock databases.

Architectural Remediation

Eliminating integration drift requires removing schema responsibility from natural language prompts: 1. Pydantic and Schema Enforcement: Use strict schema validators to catch format discrepancies before execution. 2. Finite State Machines: Ensure multi-step agent actions follow rigid, verified paths. 3. Centralized Semantic Routing: Route user intent to specialized deterministic executor tools rather than relying on open-ended code generation.

Engineering deterministic stability means designing systems where model variation cannot corrupt core infrastructure.

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

The Solution: Deterministic Agentic Engineering

hugo — Tue, 01 Sep 2026 00:00:00 +0000

The Solution: Deterministic Agentic Engineering

Over ninety percent of enterprise artificial intelligence proofs of concept fail when transitioning to production.

The failure is structural. Machine learning teams connect stochastic reasoning engines directly to rigid legacy infrastructure. When probabilistic models meet inflexible databases, integration drift and unhandled edge cases destroy operational trust.

At HSN Labs, we do not build shallow wrappers. We engineer deterministic infrastructure for mission-critical operations.

The Core Problem: Why Agents Break in Production

Missing Business Ontologies: Models do not understand corporate domain rules, transaction invariants, or relationship graphs. They guess schema logic and hallucinate parameters.
Fragile Execution: Natural language prompts cannot guarantee predictable JSON payloads or SQL statements across millions of executions.
Lack of Production Tracing: Teams deploy agents without automated evaluation pipelines, making runtime debugging impossible.

The HSN Labs Delivery Framework

1. Personalized Business Ontologies

We tailor domain schemas and operational constraints directly to live ERP, CRM, and database models. The model never guesses business logic because permissible state transitions are strictly governed by an executable graph.

2. Deep Agent Infrastructure

We build stateful multi-step execution graphs, isolated persistent memory, and standardized Model Context Protocol integrations. Agents operate with predictable tool access within audited enterprise perimeters.

3. Deterministic Guardrails

We isolate transactional writes behind formal finite state machines. In banking, agents never modify financial balances directly. In healthcare, patient data access is governed by strict schema boundaries with zero data exfiltration risk.

4. Continuous Evaluation and Observability

We govern the entire lifecycle using market standards such as LangGraph and LangSmith. Every run is traced, scored against regression test suites, and monitored for integration drift in production.

Forward Deployed Engineering

Traditional enterprise software forces companies to adapt business processes to rigid third-party platforms.

We do the opposite. Our Senior Forward Deployed Engineers embed directly into client infrastructure, building bespoke agentic systems tailored to real production systems.

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