Dumping entire conversation histories and ERP states into expansive LLM context windows degrades decision quality. Here is how we build durable agentic workflows.

Why Monolithic Agent Memory Fails in Production

There is a persistent myth in enterprise AI implementation: that an intelligent agent becomes more capable the more raw history it is fed. In 2024, teams celebrated one-million-token context windows as the death of deterministic architecture. By now, anyone running autonomous multi-step agents against production databases knows the reality. Massive context windows do not solve state management; they merely provide a larger surface area for context rot.

When you give an agent an ever-growing scratchpad containing raw logs, system tool calls, intermediate reasoning traces, and customer replies, performance degrades predictably. The model begins attending to obsolete conditions, hallucinates constraints that were resolved three turns ago, and burns through inferencing budgets with diminishing returns.

If you want agents that complete complex, multi-day operational tasks reliably, you must stop treating the language model as your database.

The Pathology of Context Pollution

Context pollution occurs when an agentic system fails to distinguish between working memory, historical record, and persistent truth.

Consider an agent tasked with vendor invoice reconciliation. The model must cross-reference a PDF invoice against a purchase order in SAP, ping a warehouse manager on Slack about a damaged consignment, wait six hours for a reply, and then adjust the ledger entry.

In a naive architecture, the entire execution trace—every API payload, retry backoff, Slack draft, and raw SQL response—is concatenated into a rolling message list. By step twenty, three distinct failure modes emerge:

Attention drift: Foundational system instructions set in the original prompt are drowned out by megabytes of peripheral structured data.
Stale truth traps: If the vendor originally submitted an incorrect bank detail that was subsequently corrected in step eight, the model may revert to the initial erroneous figure during the final payment execution in step sixteen.
Exponential latency and cost: Processing five hundred thousand input tokens on every reasoning loop creates an untenable cost profile and introduces latency spikes that break downstream API timeouts.

The Pattern That Actually Works: Decoupled State Machines

Resilient enterprise automation relies on a strict separation of concerns. The LLM is an ephemeral reasoning engine, not a state store. The orchestration layer—written in robust, deterministic code like Python or Go—must own the truth.

Instead of one long-lived, discursive agent, production-grade workflows utilise a directed graph of micro-agents coordinated by an external state machine.

Deterministic backbone: State transitions, authorization boundaries, and core business logic remain hard-coded. If a transaction must never exceed £10,000 without human sign-off, that guardrail lives in code, not in a system prompt.
Scoped context injection: When an agent spins up to execute a task, it receives only the precise schema-validated data required for that immediate sub-task. It has zero knowledge of the twenty operations that preceded it, only their validated output.
Lossy summarisation engines: Upon completing an action, a secondary lightweight model compresses the execution outcome into a typed state update (for instance: {status: 'discrepancy_resolved', approved_value: 8450.00}). The raw reasoning trace is logged to external observability platforms and immediately pruned from active memory.

Practical Example: Multi-Depot Freight Routing

We recently re-architected an automated dispatch platform for a UK logistics client handling bespoke intermodal freight. The legacy setup ran a monolithic ReAct agent that attempted to hold the entire live fleet schedule, weather alerts, driver hours regulations, and customer requirements in a shared context window. It hallucinated driver compliance breaches weekly.

We replaced it with a three-tier architecture:

State Layer (Postgres + Redis): Maintains absolute truth on driver tachograph hours, trailer availability, and depot capacity.
Evaluator Agents (Isolated): When an unassigned shipment arrives, three distinct, single-turn LLM calls evaluate route feasibility in parallel against strictly filtered subsets of depot data.
Reconciliation Node (Deterministic Code): A deterministic solver takes the three proposals, validates them against mandatory DVSA rules, and commits the state change.

Inference costs dropped by 74 per cent. Task completion reliability moved from 81 per cent to 99.4 per cent. More importantly, when an edge case fails, developers can pinpoint the exact node in the directed acyclic graph that failed, rather than reading through a ninety-page LLM transcript.

Building for Production

True agentic capability is not about how much context a model can ingest; it is about how cleanly your system discards irrelevant data. The next phase of enterprise AI adoption belongs to teams who understand classical distributed systems engineering just as deeply as they understand transformer mechanics.

Treat LLMs as volatile compute engines, not durable storage layers.