Skip to content

Blog

LATAM Airlines: Deterministic Agents in a 3% Margin Business

Reading time: 4 minutes. Author: Hugo Nascimento.

Context: I analyzed LATAM Airlines public disclosures and LangSmith telemetry to understand how an enterprise operating on three percent margins deployed agents across millions of interactions without burning capital on unneeded token overhead.

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 for flights, hotels, and 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 such as baggage and 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.

Why LLM-as-a-Judge Fails in Banking

Reading time: 4 minutes. Author: Hugo Nascimento.

Context: I drafted this critique after an AI vendor presented a deck to a banking client claiming ninety-nine percent accuracy based entirely on asking their model if its own answers were good. In regulated industries like banking and healthcare, circular evaluations fail compliance audits immediately.

Using a probabilistic language model to evaluate another probabilistic language model is circular reasoning disguised as science.

A few months ago, I participated in an enterprise architecture review with a Tier-1 financial institution. An external vendor had spent four months building an automated credit analysis agent and was presenting their results to the risk committee. They displayed a sleek slide showing a ninety-nine point two percent accuracy rate.

I asked the vendor lead a simple question: How did you calculate that accuracy metric?

The answer was breathtaking: they took the agent outputs, fed them into another prompt window, and asked GPT-4 to rate the response on a scale from one to five for accuracy and policy adherence.

They were using a probabilistic model that hallucinates to check whether another probabilistic model had hallucinated. The risk committee was seconds away from approving an architecture where no human or deterministic program had ever verified ground-truth financial math.

Why Stochastic Evaluation Fails Banking Risk Audits

In an academic paper or a consumer demo, LLM-as-a-judge is an acceptable heuristic for subjective qualities like conversational tone or stylistic flair.

In regulated banking environments, credit risk modeling, and fraud compliance oversight, relying on model-based grading is an immediate regulatory failure:

1. Shared Statistical Blind Spots

Evaluator models share the same training distribution biases as generator models.

If a generator model produces a plausible-sounding legal justification that misinterprets a central bank circular or an insurance policy exclusion, an evaluator model prompted with the same context will almost always agree. The evaluator does not query the real world or run mathematical proofs; it merely checks if the prose sounds coherent.

2. Prompt Fragility and Metric Drift

A stable enterprise engineering metric must be reproducible.

When you use an LLM as your judge, changing a single comma in your evaluation prompt, or an upstream provider deploying an unannounced weights update, can swing your accuracy score by fifteen percentage points overnight. You cannot build a dependable production release gate on a ruler that stretches and shrinks at random.

3. The Masking of Catastrophic Tail Risk

An evaluator model that awards an average score of four point eight out of five sounds impressive to a non-technical executive.

What that average conceals is that in two out of every one hundred transactions, the model committed an illegal funds transfer or leaked personally identifiable information. In regulated industries, an average score does not protect you from regulatory fines or criminal liability. A single tail-risk failure can shut down your operation.

How We Evaluate Enterprise Agents at HSN Labs

At HSN Labs, we reject subjective prompt grading in enterprise pipelines. We evaluate autonomous systems using the same rigorous engineering standards applied to critical financial and aerospace software:

  • Binary Invariant Assertions: We write deterministic assertion functions in Python. Did the output JSON strictly conform to the Pydantic schema? Did the debit and credit ledger entries balance to exactly zero? Did the response omit tax IDs and restricted account numbers? These tests return a binary pass or fail, not a subjective opinion score.
  • Immutable Golden Datasets: Every production incident, edge case, and edge failure is turned into an immutable test fixture. Before any updated agent graph or model checkpoint touches staging, it must pass hundreds of historical regression tests.
  • Full Telemetry and Replayability: We instrument every workflow with LangSmith, tracing every token, intermediate state, and tool invocation. If an agent produces an unexpected state transition, our engineers can replay the exact execution trace deterministically in local development.

Do not grade production agents with subjective opinion prompts. Grade them with deterministic code and verifiable mathematical proofs.

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

Case Study: 42 Calls in a Loop at 2 AM

Reading time: 4 minutes. Author: Hugo Nascimento.

Context: I wrote this after a late-night debugging session where an open-ended agentic loop executed forty-two recursive tool calls on a staging server before triggering cloud rate limits. This is why enterprise autonomy requires mathematically bounded state machines.

At two o'clock in the morning on a staging cluster, an alert woke our on-call team.

An open-ended autonomous agent was trapped in a runaway execution loop. For eight consecutive minutes, the model fired forty-two sequential tool calls without human oversight. It encountered a single foreign key database error, panicked, and began fabricating synthetic customer IDs in an attempt to satisfy the broken constraint. By the time provider API rate limits severed the connection, the agent had burned through thirty dollars in token costs to accomplish absolutely nothing.

Letting a large language model execute tools inside an open-ended reasoning loop in production is an engineering disaster waiting to happen.

If you browse GitHub or watch online agent tutorials, you will find the same ubiquitous design pattern: the ReAct loop. You give the model a system prompt, pass an array of thirty different Python functions, and tell it to think step-by-step, invoke any tool it wants, inspect the output, and keep looping until it feels the task is complete.

In a YouTube tutorial with two dummy functions, this looks magical.

In an enterprise banking or ERP environment with real money and real databases, an unconstrained ReAct loop is an unmitigated liability.

The Mathematical Collapse of Unconstrained Probability

Language models are stochastic next-token predictors. Every tool selection is a probabilistic bet.

When you chain probabilistic bets inside an open-ended loop, the mathematics work aggressively against you:

1. Compounding Probability Collapse

Suppose your model has a ninety percent probability of picking the correct tool and parameters on any single step.

If a business workflow requires five consecutive steps, the probability of the entire chain executing without error is fifty-nine percent. By step seven, you are down to forty-seven percent. You are essentially flipping a coin on whether your production system will execute or crash.

2. The Hallucination Repair Death Spiral

What happens when an unconstrained agent makes a mistake?

When a database returns an error or an API returns a 400 Bad Request, an open-ended agent tries to reason its way out. Instead of stopping, it invents a new query. It calls another tool to fix the error it just made, compounding hallucinations until state corruption occurs.

3. Out-of-Sequence State Mutations

An unconstrained model has no inherent concept of enterprise causality. In an open-ended setup, nothing prevents the model from issuing a payment refund before the return shipment is logged, or marking a contract approved before compliance validation completes.

The Solution: Stochastic Planning, Deterministic Execution

At HSN Labs, we never permit open-ended tool loops in production. We enforce a strict separation between reasoning and execution through Finite State Machines:

  • Discrete Permissible States: At any given microsecond, an enterprise transaction exists in an explicit state: Draft, Validated, Approved, or Committed. The agent is only allowed to see and propose tools that belong to that specific state. It is physically impossible for an agent in Draft state to trigger a Commit action.
  • Invariant Guard Functions: Transitions between states are not governed by the language model. They are governed by deterministic Python guard functions. Even if a model suggests an order cancellation, the software guard checks whether goods have already left the fulfillment center. If the guard evaluates to false, the transition is rejected at the architecture level.
  • Proposals Instead of Direct Writes: The language model never holds database write credentials. The model is treated as an untrusted proposal engine. It analyzes unstructured natural language and proposes a state transition payload. Deterministic schema validators like Pydantic parse the payload, check invariants, and execute the database write.

Autonomy is not the absence of rules. Enterprise autonomy is the ability of software to execute reliably because the boundaries are mathematically unbreakable.

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

Why I Never Use Normal RAG on Financial ERPs

Reading time: 4 minutes. Author: Hugo Nascimento.

Context: This essay came out of an emergency technical audit where an agency tried to calculate corporate accounts payable using cosine similarity over embedded invoice chunks. The resulting hallucinations almost corrupted the client ledger.

Connecting standard Retrieval-Augmented Generation to an Enterprise Resource Planning system is an architectural trap.

Over the past two years, I have lost count of how many enterprise teams have approached me after burning months trying to make vector search read corporate financials. The premise sounds tempting to a non-technical executive: dump all purchase orders, vendor invoices, contracts, and database exports into a vector database, then let an LLM retrieve relevant chunks to answer operational questions.

In production, this approach collapses on basic arithmetic.

Semantic Closeness Is Not Mathematical Truth

Vector embeddings measure semantic similarity in natural language. They know that words like invoice, billing, and payment share conceptual proximity.

An Enterprise Resource Planning database like SAP S/4HANA or Totvs Protheus does not care about semantic vibes. It operates on immutable double-entry bookkeeping, strict foreign key constraints, primary keys, and statutory fiscal periods.

Cosine distance is mathematically incapable of answering relational enterprise queries.

1. Vector Search Cannot Join Tables

Imagine a CFO asking: Which open purchase orders above fifty thousand dollars from last month lack a corresponding delivery receipt?

To answer that question correctly, an engineer must execute relational joins across at least four normalized tables: purchase orders, line items, goods receipts, and vendor tax records.

A vector database searches for text chunks that mention purchase orders and large amounts. It cannot join foreign keys. It cannot filter out canceled records. It pulls five text snippets that sound relevant, feeds them into the prompt, and the model fabricates a plausible list that omits critical transactions.

2. Debits and Credits Must Zero Out

In corporate accounting, balances are absolute invariants. Every debit must match an equal credit.

When you chunk a ledger table into vector embeddings, you slice relational rows into disconnected text fragments. The model retrieves seven out of ten line items because three fragments had lower semantic relevance scores. When the model attempts to calculate the balance, it hallucinates a sum based on incomplete data.

In enterprise finance, being ninety-five percent accurate is identical to being completely broken.

3. The Nightmare of Temporal Boundaries

Enterprise data is strictly bound by fiscal calendars, currency exchange rates, and tax jurisdictions.

Vector search has no inherent concept of temporal sequence. Unless an engineer manually partitions indices by fiscal month, a semantic query will happily retrieve tax withholding rules from two years ago alongside current invoices, generating calculations that breach local tax authority requirements like SPED in Brazil or statutory reporting in North America.

What I Build Instead: Executable Ontologies

At HSN Labs, we do not let language models guess relational SQL or search raw embeddings for financial truth. Here is the exact architecture I enforce instead:

  • Pre-Compiled Business Ontologies: We map the enterprise schema into an explicit knowledge graph that defines verified relationships, valid join paths, and business rules before any query runs.
  • Strictly Typed Query Generation: The agent does not generate open-ended SQL strings. It selects parameterized query templates validated against strict Pydantic schemas. Every parameter is checked before it touches the read replica.
  • Hard Invariant Assertions: When the database returns records, deterministic assertion layers verify ledger balances, currency alignment, and temporal validity before context reaches the user or downstream worker.

If an architecture cannot guarantee mathematical precision on financial records, it does not belong in enterprise production.

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 Integration Drift: When Prompts Break Production

Reading time: 3 minutes. Author: Hugo Nascimento.

Context: I documented this post-mortem after an unannounced upstream model update silently altered JSON field types, crashing an accounts payable pipeline overnight at an enterprise client. Prompts cannot serve as enterprise API contracts.

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

Connecting an unconstrained language model directly to an enterprise database or ERP endpoint creates a critical architectural failure point known as integration drift.

Last year, I received an emergency call at three o'clock in the morning from an engineering director. Their automated invoice processing system had been operating smoothly in production for three weeks. Suddenly, without a single line of client code changing, their downstream microservices began throwing hundreds of 500 Internal Server Errors, halting their entire night batch run.

The root cause was integration drift. The upstream cloud model provider had deployed an unannounced minor checkpoint update to their model weights.

How Prompts Silently Corrupt Enterprise Pipelines

During development, an engineer writes a prompt asking the model to return a structured JSON object. The model complies, outputting valid fields during staging tests.

Two weeks later, the exact same prompt produces subtle structural mutations: * An integer field like customer_id suddenly returns as a string with leading zeros. * A mandatory foreign key is omitted because the model summarized an ambiguous invoice note. * An uppercase enum value like STATUS_APPROVED is substituted with a near synonym like STATUS_CONFIRMED. * Nested arrays flatten into comma-separated strings.

To a human reader inspecting the output in a chat window, these differences seem trivial.

To a downstream PostgreSQL database, a FastAPI endpoint, or an enterprise service bus, they are fatal parsing exceptions. Batch jobs abort, database locks stall, and human engineers are forced to pull late-night shifts to clean up corrupted records.

Eliminating Integration Drift at the Architecture Layer

At HSN Labs, we treat natural language prompts as completely untrusted input. We eliminate integration drift by removing schema responsibility from the model:

  • Strict Pydantic Schema Parsing: Every model output is intercepted by a deterministic schema validator before it can touch enterprise infrastructure. If a field type drifts by a single character, the payload is caught and sanitized at the perimeter.
  • Semantic Routing with Parameterized Executors: We never let models generate open-ended code or direct API query strings. The model is restricted to intent classification and parameter extraction. Deterministic software workers construct the actual API payloads using pre-compiled templates.
  • Finite State Transition Guards: Multi-step agent operations are bounded by finite state machines. If an upstream model update causes an agent to suggest an illegal state transition, the state machine guard rejects the transition before any database write executes.

Engineering deterministic stability means designing systems where upstream model drift cannot corrupt your core corporate infrastructure.

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

Chatbot vs Agent: Why Replacing BPOs Requires Deterministic Guardrails

Reading time: 3 minutes. Author: Hugo Nascimento.

Context: I wrote this note after an executive briefing where an enterprise director claimed their company had deployed thirty agents. When I inspected their codebase, all thirty were basic text chatbots answering internal HR policy questions. None of them could execute a single transaction.

A chatbot answers text questions. An autonomous 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 deliver financial returns.

When a company deploys an internal chat interface that summarizes PDF policy documents, it has created an informational tool. It has not eliminated an operational cost center.

If your strategic objective is to terminate a multi-million-dollar third-party BPO contract, conversational answers are useless. You need software that executes real work: * Reconciling thousands of incoming vendor invoices against ERP purchase orders in SAP or Totvs. * Validating inventory allocations across multiple distributed warehouse databases. * Adjudicating customer billing disputes according to strict contract terms. * Committing double-entry financial ledger changes with immutable audit trails.

The Human-in-the-Loop Purgatory

When software teams connect probabilistic language models directly to enterprise systems without deterministic constraints, they quickly realize that models hallucinate.

Terrified of corrupted database records or unauthorized payouts, their immediate reaction is to insert a human verification step into every single agent decision.

This creates what I call Human-in-the-Loop Purgatory.

If a human analyst must review and approve every single invoice match, customer refund, or timecard adjustment, your labor costs remain completely unchanged while transactional latency explodes. You have not built an autonomous digital workforce; you have built an expensive, slow user interface for your existing staff. The financial ROI of replacing the outsourced BPO contract evaporates entirely.

The Deterministic Path to True Autonomy

True autonomy does not mean letting a model run wild without supervision. True autonomy means establishing mathematical certainty around routine transactions so humans only handle real exceptions:

  • Mathematically Bounded State Machines: The agent can only execute actions permitted by the current transactional state. An agent cannot trigger a payout while an invoice is in verification state.
  • Hard Schema Enforcement: Every data payload is parsed and validated by strict Pydantic schemas before any production API is invoked. If an input field violates the schema, the execution is halted before touching corporate infrastructure.
  • Asymmetric Exception Escalation: Ninety-five percent of routine transactions pass all invariant checks and execute autonomously at machine speed. The remaining five percent containing true anomalies or contract disputes are packaged into clean diagnostic payloads and escalated to senior human managers.

Autonomy is not created by writing longer system prompts. Autonomy is created by building deterministic architectures that make operational failure impossible.

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.

Why I Built HSN Labs

Reading time: 4 minutes. Author: Hugo Nascimento.

Context: Over five years building Eva and serving dozens of enterprise clients, I learned how AI agents actually behave in production by failing repeatedly in the trenches. Here is why I decided to stop saying no to advisory projects and launch HSN Labs.

Eva stands for employ virtual agents.

For the past five years leading Eva as founder and CPTO, I have lived entirely in the enterprise AI trenches. Long before generative artificial intelligence became the dominant tech talking point, we were already building, testing, and deploying virtual workers into complex corporate environments.

Along that journey, we had the privilege of working with dozens of enterprise clients across multiple industries, including organizations such as Deloitte, Santander, Unipar, Softplan, Cast Group, LWSA, Turbi, and Caju.

I did not learn agent architecture from academic research papers or YouTube demos. I learned it the hard way: by failing in production.

Over five years of shipping real software to real enterprise users, I watched every conceivable point of failure occur in live environments. I saw prompts silently drift after upstream model updates. I watched microservices choke on unexpected database formats. I saw unconstrained reasoning loops fire redundant calls, and I saw how fragile conversational interfaces collapse the moment they encounter dirty corporate data.

Through hundreds of iterations, emergency patches, and sleepless nights, we figured out what actually works: rigid schemas, domain ontologies, finite state machines, and continuous production tracing.

Why I Kept Saying No to Consulting

As our deployments matured, a consistent pattern began to emerge.

Enterprise leaders, CIOs, and innovation directors would reach out to me. They saw what we were running and asked if I could step in to help design their internal agent strategy, audit their vendor proposals, or fix an AI pilot that was stuck in sandbox purgatory.

For years, I gave them the exact same answer: no.

My focus was clear. As a venture-backed SaaS founder, my job was to grow monthly recurring revenue at Eva. Taking on advisory engagements or custom architecture consulting felt like a distraction from building our core software product. Consulting simply was not what I was looking to do at the time.

The Market Shift and the Launch of HSN Labs

Over the past eighteen months, the enterprise technology landscape shifted violently.

Every corporate board began demanding an immediate artificial intelligence strategy. Millions of dollars poured into innovation budgets. Yet, nearly every enterprise team I spoke with was running into the exact same wall we hit years earlier: building slick demos that died the moment they touched live corporate databases and strict compliance rules.

Enterprises were burning fortunes with traditional strategy firms that delivered one-hundred-page slide decks with zero lines of working code. Or they hired agencies that connected raw language models directly to enterprise SQL databases, creating massive security hazards.

The demand for pragmatic, battle-tested engineering leadership became too large to ignore. I realized that the lessons we learned from years of production failures were precisely what enterprise leaders needed to avoid burning millions of dollars.

That is why I built HSN Labs.

The Hybrid Workforce Transition

I believe deeply in the future of humanity with a hybrid workforce transition.

The future is not about replacing human workers with cold automation. The future belongs to hybrid organizations where autonomous digital workers handle high-volume, repetitive, deterministic operations around the clock, freeing human talent to focus on relationship management, creative judgment, and strategic decision-making.

That transition cannot be achieved through theoretical presentations or fragile chatbot wrappers. It requires deep systems engineering: complete lifecycle management spanning business ontology design, secure infrastructure, bounded orchestration, and continuous evaluation in production.

HSN Labs is the engineering boutique I built to partner with enterprise leaders who are already actively pursuing this transition and demand production systems that do not break.

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