May 20, 2026
Sly Data: The Deterministic Backbone of Multi-Agent AI Systems
Sly Data: The Deterministic Backbone of Multi-Agent AI Systems
How Sly Data creates a secure, deterministic foundation for multi-agent AI systems by separating sensitive enterprise state from probabilistic LLM reasoning.
Why Multi-Agent AI Systems Need Deterministic Control
Traditional Large Language Models (LLM) are probabilistic but enterprise systems are not. When building multi-agent AI systems, we combine deterministic systems such as databases, workflows, and sensors with probabilistic reasoning engines like LLMs. Without architectural discipline, this combination becomes unstable.
As organizations move from simple copilots to complex multi-agent systems, maintaining consistency across agents becomes increasingly difficult. Different agents may interpret the same context differently, operational state may drift over time, and sensitive information can unintentionally leak into prompts. These challenges become especially important in enterprise environments where workflows must remain reliable, auditable, secure, and repeatable.
Sly Data provides a deterministic backbone that securely stabilizes multi-agent AI systems. It creates a structured and governed way for agents and systems to exchange operational state without exposing sensitive enterprise data directly to LLM prompts. Instead of relying entirely on conversational context, Sly Data introduces controlled state management between agents, tools, and enterprise systems.
This security layer is important because prompts are not designed to function as long-term enterprise state storage. As multi-agent systems grow more interconnected, organizations need a way to control what information agents can access, what data can move between systems, and how that data is governed. Sly Data addresses this by introducing explicit authorization, schema validation, auditability, and directional controls into the architecture itself. Within neuro-san, the open source agentic framework, Sly Data serves as the secure state exchange layer that enables governed and reliable data passing between agents and enterprise systems.
The result is a more secure and reliable foundation for enterprise AI systems that need to operate consistently at scale.
What Is Sly Data?
Sly Data (Structured Layered Exchange Data) is a deterministic, schema-controlled, tool-mediated data contract used to securely exchange state between agents and systems without exposing sensitive data directly to LLM prompts.
It is explicitly whitelisted, schema-validated, auditable, and directionally controlled.
At its core, Sly Data is designed to separate sensitive operational state from probabilistic reasoning. Instead of embedding enterprise data directly inside prompts or agent conversations, systems exchange information through controlled private data channels. This reduces the risk of sensitive information leaking into prompts while also improving consistency across workflows.
In practical terms, Sly Data acts as a secure interface layer between reasoning and execution. LLMs handle reasoning and interpretation while deterministic systems handle execution and operational state. Sly Data sits between them, ensuring exchanges remain controlled, predictable, traceable, and secure.
This separation becomes especially important in enterprise environments where systems need to maintain consistency across workflows and across multiple interacting agents. By moving operational state into structured data channels instead of conversational memory alone, organizations can reduce ambiguity, improve governance, and create more reliable multi-agent architectures.
The Architecture Pattern
In a single-agent system, the LLM handles reasoning while tools manage deterministic execution. Sly Data exists within private data channels, separating probabilistic reasoning from enterprise state management.
Figure 1: Diagram of a single agent system
This separation allows the system to maintain a clean boundary between natural language reasoning and operational execution. The LLM interprets intent and determines actions, while tools and structured state ensure the workflow remains deterministic and reproducible.
In multi-agent systems, each agent request maintains its own private data channel, and structured Sly Data governs exchanges between agents.
Figure 2: Diagram of a multi agent system
As systems scale into larger agentic architectures, this becomes increasingly important. Agents are no longer operating independently. They must coordinate actions, share operational context, and maintain consistent state across workflows. Without structured exchange mechanisms, information can become inconsistent as it passes between agents.
Sly Data provides a controlled way for agents to exchange trusted state without depending entirely on prompts or conversational history.
Real-World Example: “Engines Stop” Agentic System in the Context of Airline Turnaround at Airport
Aircraft turnaround refers to the process between an aircraft arriving at a gate and departing again. During this window, several operations must be completed:
Taxiing to gate
Securing the aircraft wheels
Engines stopping
Jetway connection
Door opening
Passenger deboarding
Cabin cleaning
Refueling
Catering replenishment
Boarding
The engine’s stopping task has dependency: the aircraft should be stopped at the gate and its wheels secured with wheel chocks at the designated mark. That sets the flight status to “on-blocks”.
The “Engines Stop” agentic system requires parameters such as aircraft type, flight number, flight status, and gate ID. These are either extracted from prompts or retrieved from Sly Data when triggered by another agent. It returns an update on engine stop status.
Figure 3: Diagram of data flow in a multi agent system for engines stop when it is called directly from the prompt.
This example highlights a broader challenge in enterprise multi-agent systems. Some workflows begin with direct user interaction, while others are initiated entirely by agents communicating with each other. In both cases, the system must maintain reliable operational state throughout the workflow.
Case of User Prompt
When a user directly interacts with the system, the process begins with the LLM interpreting the request and extracting the key operational details such as aircraft type, flight number, flight status, and gate ID. These parameters are then handed off to specialized agent tools, which carry out the required actions with precision.
But the process does not stop at execution. To ensure continuity and coordination across the system, these same parameters are recorded in a private data channel called Sly Data. This allows other agents to access a consistent, trusted state without relying on the original prompt or potential hallucinations in “telephone” copies made between agent chat streams.
This becomes important in larger workflows where multiple agents may participate in sequence. Instead of each agent attempting to infer context independently, they can retrieve the same validated operational state directly from Sly Data. That reduces ambiguity and improves consistency across the workflow.
Figure 4: Diagram of agent execution of direct user prompt.
Case of Call by Another Agent
Things work a bit differently when an agent is triggered by another agent rather than a user prompt. In this scenario, there is no natural language input for the LLM to parse, so it cannot extract the required parameters on its own.
Instead, the system relies on Sly Data. The agent retrieves the necessary values such as flight details and status directly from its private data channel, ensuring it has the exact context needed to proceed. Two code examples are provided in Figure 5.a.
def _from_args_or_sly(args: Dict[str, Any], sly: Dict[str, Any], key: str) -> Any:
"""Prefer args[key]; fallback to sly_data[key]."""
v = args.get(key)
return v if v is not None else sly.get(key)# flight number is needed in particular.
flight_number: str = args.get("flight_number", None)
if not flight_number:
print("No flight number provided. Trying to get it from sly_data")
flight_number = sly_data.get("flight_number")Figure 5a: Sample code command for the reading sly data when a system is not called from prompt or when LLM cannot provide argument to agent.
After completing the task, any updates are written back to Sly Data, keeping the system’s state consistent and available for other agents. See figure 5.b.
sly_data["engines_stop_status"] = engines_stop_status
return engines_stop_statusFigure 5b: Sample code command for writing parameter value back to sly data channel prior to returning updated value to agent.
This seamless handoff between agents, powered by structured data rather than prompts, is illustrated in Figure 5.c.
Figure 5c: Diagram of agent execution of indirect user prompt thru another agentic system.
This approach allows agents to collaborate using structured operational state instead of depending entirely on conversational context. As systems grow more complex, this distinction becomes critical for maintaining reliability across workflows.
Sly Data within and between Agentic Systems and Cross-System Governance
By default, Sly Data flows within a private data channel inside an agentic system, acting as a secure and efficient backbone for communication between agents. This internal channel ensures that data moves fast and safely, without exposing sensitive information or compromising system integrity.
As systems grow more complex, architectures often evolve into modular designs. Business processes are broken down into independent functional blocks, each operating as its own agent. These agents do not just respond to user prompts. They can also call one another directly, forming a network of interconnected capabilities.
This shift introduces a new challenge: how do you securely share data across these boundaries?
The answer lies in extending Sly Data beyond a single system. With controlled cross-system channels, Sly Data enables agents in different modules to exchange information in a governed way. Using explicit “allow” rules, systems define exactly what data can be shared, in which direction, and under what conditions as shown in figure 6.
The result is a secure, auditable, and highly controlled data exchange layer that scales with the complexity of modern multi-agent architectures.
# Specify the sly data that would be exchanged between this network and an upstream adjacent network.
"allow": {
"from_upstream": {
"sly_data": {
"flight_number": true,
"aircraft_type": true,
"flight_status": true,
"gate_id": true
}
},
"to_upstream": {
"sly_data": {
"engines_stop_status": true
}
}
},Figure 6: Configuration of sly data transfer control across remote agentic systems. The “allow” indicates authorization of data transfer. “from_upstream” and “to_upstream” specify the direction of the authorized exchange.
This governance model allows organizations to scale multi-agent architectures while still maintaining visibility and control over how operational state moves between systems.
Why It Matters
Without Sly Data:
Sensitive data may leak into prompts
State becomes inconsistent
Workflows are not replayable
As multi-agent systems grow larger and more autonomous, these issues become harder to manage. Inconsistent state between agents can lead to unreliable execution, duplicated actions, or workflow failures. Lack of auditability also makes enterprise governance significantly more difficult.
With Sly Data:
Exchanges are explicit and authorized
Systems remain deterministic
Multi-agent AI becomes enterprise-ready
Sly Data creates a more stable foundation for enterprise AI by separating operational state from probabilistic reasoning. This allows organizations to build systems that are not only intelligent, but also secure, traceable, and reliable at scale.
Building Reliable and Secure Multi-Agent AI Systems
Ultimately, the bottom line is this: LLMs bring intelligence, tools bring execution, and Sly Data brings control.
Together, they enable scalable multi-agent AI.
As enterprises continue moving toward increasingly connected agentic systems, deterministic state management will become a core architectural requirement. Sly Data addresses that challenge by providing structured, governed, and secure state exchange between agents and systems.
In neuro-san, the open-source agent orchestration framework, Sly Data is used as the secure data passing layer between agents and systems. Instead of relying entirely on prompts or conversational memory, neuro-san uses structured Sly Data channels to maintain consistent operational state, govern data exchange, and protect sensitive enterprise information throughout multi-agent workflows.
The result is a more reliable way to build enterprise multi-agent AI systems that can scale while maintaining consistency, security, and operational control.
Solution Architect with Product Management experience in SW OS and stack for IoT, Cloud and Edge Computing