Agentic Systems Beyond the Hype: Why You Need Both Local and Global Perspectives to Build Agentic Systems

Having both local and global perspectives is one of the most valuable skills a software engineer can develop. We learned this lesson in distributed systems and cloud computing, where the behavior of a single component does not necessarily represent the behavior of the system.

In a previous post I looked at the local axis — task and model profiling. Here I look at the global one.

Agentic systems introduce the same challenge. Without distinguishing local behavior from global behavior, engineers risk diagnosing the wrong problem, implementing the wrong solution, and misunderstanding how the system actually operates.

Nowadays, most of the time engineers focus their attention on the agent as a whole in agentic systems, providing it with memory, tools, context, prompts, etc. This approach feels right when everything is working as expected, and when the agent acts as isolate element, but what about when we introduce DBs, RAG, Context Cache, and more agents? With these new points of failure in the scene, a global and collaborative perspective is required to understand and fix the issues, behind the distributed systems.

Agent behavior is not system behavior

The normal reaction when we see an agentic systems failing is blaming the agent, and looking at what was wrong in the implementation. Agents act, representing a stage in a bigger process, the root causes of its failure could be:

Where the failure originates:

• Wrong data format
• Networking
• Permission
• Tool calling
• Prompts
• Context degradation

What mitigation was missing:

• lack of retries or fallbacks
• No circuit breakers

In some cases the agent failure could not be as important as we think, if a retry or fallbacks were implemented. Understanding this global context will allow us to implement Fault tolerance patterns.

Agent Memory is not System Memory

The global perspective also will help us to understand the differences between agent memory and system memory, and how or when we can implement it.

When we work with agents, in some cases context needs to be stored in order to construct a linear history around the work in process. But when we extend to more agents, or swarm of them, this memory needs to be extended to cover bigger gaps in the swarm behavior. Long-term memory could be our the first option, and here, is where we introduce the global perspective, analyzing the interaction between agents and what additional information besides the actual context all the agents will need.

Build a system long-term memory will provide to the swarm the ability to understand the whole process, preventing to agent of assumptions or inferencing over missing information. This same situation apply to context where the context of the agent is totally different from the context of the whole system.

System Context Degradation

While prompts, context, and instructions travel through an agentic system, we can experiment context degradation this could be one of the causes of unexpected results or failures.

This phenomenon shows up when an agent has received the instruction, directly from another agent, or when someone has asked to build a prompt to be sent to another one. In this case the original goal starts to come blurry as it crosses N agents. If we preserve a system context, the original objective can be passed to the Nth agent in turn, along with specific context or instruction.

Engineers must take into consideration inference and ambiguity in agentic systems i.e.: each time the LLM loops in context compression and inferencing could end up whith differences between results. As working context –which is not the same as LLM or Agent context– increases, in order to save memory and tokens, this needs to be compressed over and over. At the same time, when it needs to build a new instruction, it tends to optimize for inference, which could degrade the original objective.

This are just some examples of how global perspective its importance when it came to architect agentic systems, reminding us the importance of design and architecting agentic systems rather than just develop them. Seeing both perspectives apart is not enough — in the next post, how they come together.