Cognizant AI Lab Releases Neuro SAN to Orchestrate Data-Driven Multi-Agent Networks

Cognizant AI Lab has released Neuro SAN (Neuro AI System of Agent Networks), an open-source Python library designed to build and run multi-agent artificial intelligence networks. Released under the Apache License 2.0, the framework allows developers and domain experts to orchestrate collaborative networks of specialized Large Language Models using declarative data-only configurations, shifting agent design from hard-coded Python logic to structured configuration files.

Addressing LLM Limitations Through Collaborative Agent Networks

The primary motivation behind Neuro SAN is the realization that a single Large Language Model (LLM) often struggles with highly complex, multi-step operations. When developers expect a single agent to handle a massive, open-ended problem, the model’s accuracy and performance often degrade. The project’s documentation analogizes this expectation to placing a high-school intern in the role of an adult PhD.

To solve this, Neuro SAN breaks complex problems into smaller, more manageable subtasks. It allows multiple specialized, LLM-enabled agents to communicate and coordinate with one another to resolve a single overarching query. Because different tasks require different capabilities, developers can assign specific LLMs to individual agents based on factors such as cost, latency, context-window limits, or data-privacy constraints. It also supports fallback LLM configurations to maintain system uptime if a preferred model fails.

HOCON Configurations for No-Code Agent Orchestration

Typically, assembling a multi-agent system requires writing extensive Python code to handle the logic, message passing, and execution paths. Neuro SAN alters this approach by allowing entire agent networks to be defined using HOCON (Human-Optimized Config Object Notation) files.

HOCON is a data format that can be conceptualized as JSON with comments, along with other structural conveniences. By defining the routing, roles, and boundaries of agents entirely in data-only configuration files, non-programmers and subject matter experts can author and modify complex agent networks without needing to write code. All active agents are registered in a central configuration manifest file, such as manifest.hocon.

Integrating CodedTools and the Model Context Protocol

While natural language tasks are well-suited for LLMs, deterministic operations—such as querying a web service, performing complex math, copying raw data without error, or calling third-party APIs—are not. Neuro SAN bridges this gap by integrating CodedTools.

CodedTools are traditional Python scripts that interface with LangChain or Neuro SAN’s proprietary interface. When an LLM agent encounters a task that requires absolute accuracy, it can trigger these coded functions, combining probabilistic natural language processing with deterministic code execution.

Additionally, Neuro SAN integrates with the Model Context Protocol (MCP). This design choice allows every Neuro SAN server to act as an MCP server, facilitating a uniform interface for connecting AI models to data sources and tools.

Managing Private Data with Sly-Data Channels

Handling sensitive information is a recurring challenge in multi-agent networks, as sending raw private data into LLM chat logs poses privacy and security risks. Neuro SAN implements a security feature called Sly-Data to address this issue.

Sly-Data refers to dedicated private communication channels that exist outside the primary LLM chat stream. This allows the system to pass credentials, session IDs, or sensitive datasets downstream or upstream to CodedTools and other agent networks without exposing that data to the language models themselves. The system operates on a security-by-default architecture, where users specify precisely what private data is shared at each stage.

Testing and Classifying Agent Failures with the Assessor App

Multi-agent networks are probabilistic systems, meaning the same prompt can yield different outputs across runs. To ensure these networks can be verified as reliable systems, Neuro SAN includes built-in test infrastructure.

The project features data-driven test cases, language-aware validation, and the ability for LLMs themselves to test agent networks. Central to this architecture is the Assessor app, a utility that automatically classifies the specific modes of failure for agents when they are evaluated against test cases. It also integrates with external observability and tracing tools—such as LangSmith, Langfuse, Arize Phoenix, and HoneyHive—to track system performance.

Installation and Server Execution

Neuro SAN is primarily written in Python, comprising 98% of the repository’s codebase. Running the library requires Python 3.12 or higher.

To help users launch the framework, the repository includes automated quick-start scripts for various operating systems in the /quick-start directory. To start the server on macOS or Linux, users can run:

./quick-start/start-server.sh

On Windows, the server is initiated via:

quick-start\start-server.bat

These scripts automate the creation of a virtual environment, install the required dependencies (such as those in requirements.txt), set environment variables, enable CORS, and launch the backend server.

Alternatively, developers can manually configure the environment and run the core service loop with Python:

export PYTHONPATH=$(pwd)
python3 -m venv venv
. ./venv/bin/activate
pip install neuro-san
export OPENAI_API_KEY="XXX_YOUR_OPENAI_API_KEY_HERE"
python -m neuro_san.service.main_loop.server_main_loop

Once the server is running, users can interact with agents via a built-in command-line chat client:

python -m neuro_san.client.agent_cli --http --agent hello_world

The repository also provides a Dockerfile and deploy scripts (build.sh and run.sh) to containerize the server for cloud deployments.

Recent Technical Updates in Version 0.6.79

The open-source project has maintained active development since its creation on November 15, 2024. In the latest stable release, version 0.6.79 (published on July 14, 2026), several internal fixes and utility tools were merged to enhance stability:

• Error Handling: The agent chain no longer aborts completely if an MCP tool encounters an error; instead, the system now catches the error to maintain the execution thread.
• Security & Output Cleanliness: Internal backtraces and raw error details are now suppressed from the client-facing output.
• Memory Utility: A new MemoryUtil tool using the objsize library was added to assist with real-time memory inspection.
• Performance: The core probes for Neuro SAN were shifted to run on a separate thread and event loop to avoid blocking main service routines.
• Dependency Warnings: The update removed token cost fallback tables and added a deprecation warning for the LangChain tool imported from the langchain-community package.

The project is hosted in the cognizant-ai-lab/neuro-san repository, where the public codebase contains 137 stars and 44 forks as of July 2026.

---

Source: View on GitHub