Scaling Up Config-Driven Multi-Agent Networks with Neuro SAN

TL;DR

• The origin is a pragmatic call: while experimenting with multi-agent systems two and a half years ago, the team realized the glue code — agents calling agents, agents calling tools, tools calling back — was the noise obscuring the actual work. So they lifted it out and described the whole network in configuration files. That became Neuro SAN.
• Config-driven design produced three emergent wins: a multi-agent system can call another multi-agent system as a tool (agentic webs, nestable ad infinitum, and equally able to call MCP or A2A servers); standardized invocation makes testing itself data-driven; and since the config files are just forms waiting to be filled in, you get multi-agent systems vibe-coding other multi-agent systems.
• You don't need to wait for the next great model. The real win is decomposing the problem so a smaller model can handle it — more reliably and more cheaply.
• Internal proof point: their corporate intranet now runs ~200 leaf agents coordinated by AAOSA (fronting ServiceNow, Salesforce, PeopleSoft), and ticket volume dropped roughly 30% after deployment.

Key Points

Where Neuro SAN came from, and how it's structured (~01:34–01:36)

The speaker is from Cognizant AI Lab — a "big R, little D" group of maybe 30–40 people centered in San Francisco with a contingent in Bangalore. His job is taking promising research and pushing it out so it can be scaled up.

Neuro SAN is the flagship example. Two and a half years ago, experimenting with multi-agent systems, the team quickly realized that the glue code of agents calling other agents was the noise in what they were actually trying to do — so they lifted it out. The result is a configuration-driven system where agents call other agents, agents call coded tools, and coded tools can call back into the agent system, with everything described in configuration except the coded tools themselves.

Every node in the network declares upward to its upchain callers: what it can do, what information it needs to operate, and who it can talk to — plus an overall system prompt. One bit of secret sauce he highlights: the ultimate upchain is the user. For secure credentials there's a side channel they call sly_data, so tokens you never want in the chat stream can travel separately.

Three things the config-driven design made possible (~01:36–01:38)

Two early lessons first:

• You don't need the next great model to boost capability. The real win is breaking problems down so a smaller model can handle them — more reliably and more cheaply.
• Given the right tools, all sorts of people start building multi-agent systems. Even their marketing people produced genuinely good ideas and tools that are still in use today.

The emergent capabilities:

1. Agentic webs. Once you've built a multi-agent system, it's easy for it to call another multi-agent system as a tool, ad infinitum — and equally to call MCP servers, A2A servers, or whatever other agent system you want.
2. Data-driven testing. Because the common tooling for invoking agents — secrets included — is standardized, testing becomes data-driven in itself: "this is the interaction I want to have" is just data.
3. Multi-agent systems vibe-coding multi-agent systems. Since agentic systems are described by JSON/HOCON files, those files are just forms to fill in. So they now have multi-agent systems that generate other multi-agent systems, callable as a "perishable thought" or downloadable to become part of the larger system.

Case study: the corporate intranet and AAOSA (~01:38–01:40)

The slide shows concentric circles: at the center is what they call the front man, the root of the system, calling out to middle-tier agents, with leaf agents in the outer ring doing the actual work.

The application is a corporate intranet — the company homepage you look at at least weekly. HR, finance, and IT all have different needs and different agents, yet everybody needs access to all of them. Tying it together is a prompting infrastructure called AAOSA, whose design principle is that whoever is answering the current question knows nothing, but knows who else to call. The question trickles down so HR, legal, and the rest each answer their own facet, and as information comes back up there's an aggregation of knowledge along the way.

They convinced their corporate IT department to eat their own dog food. That deployment now coordinates roughly 200 leaf-level agents via AAOSA, fronting ServiceNow, Salesforce, PeopleSoft, and the rest. He describes the scaling as "ridiculous," and the results show up directly in ticket counts: on the chart, a vertical line marks deployment, after which overall tickets dropped about 30% — the agent system was handling requests better than people overall.

Open source and what's next (~01:40–01:41)

• The stack is freely available and agreeably licensed; he encourages people to try it.
• They look forward to working with the AAIF (Agentic AI Foundation) to make it available in the Linux Foundation.
• A bring-your-own-key site is coming (the system already supports BYOK) where you can vibe-code your own multi-agent systems.

Quotes

"We quickly realized that the glue code of agents calling other agents was the noise in what we were really trying to do. And so we wanted to lift that up." (~01:34)

The founding move behind Neuro SAN: remove the glue code from the problem rather than write it better.

"We don't really need to wait for the next great model in order to boost our capability. The real win is breaking your problems down so that a smaller model can handle it — and handle it more reliably and more cheaply for that matter." (~01:36)

A deliberately contrarian note at a conference full of "wait for the next generation."

"The coordinator doesn't know anything but the people down below do." (~01:39)

AAOSA in one line: the coordinator's value is knowing whom to ask, not knowing the answer.