# Beyond Prompt Chaining: The TB-CSPN Architecture for
## 6 Case Study: Topic-Grounded Consultant Agents vs. LLM
### Quantitative Performance Evaluation
#### 6.7.5 Scalability Analysis: Addressing State-Space Explosion  
To directly address concerns about Petri Net state-space explosion in large systems, we conducted systematic scaling experiments with agent populations ranging from 10 to 100. The results show that TB-CSPN exhibits sub-linear memory growth and maintains consistent throughput and reliability at scale. In human-in-the-loop settings, supervisory interventions introduce minimal delay: manual override latency in our prototype remained consistently below 300 ms, with no measurable impact on aggregate throughput in batch-processing regimes. Why Traditional Petri Net Scalability Concerns Do Not ApplyTB-CSPN's hybrid architecture fundamentally departs from classical Petri Net applications, rendering conventional scalability concerns largely irrelevant. In traditional systems, both application logic and state are encoded within the net structure, leading to a combinatorial state-space explosion as complexity increases. By contrast, TB-CSPN uses the Petri Net substrate solely to model coordination workflows and task execution patterns, while semantic intelligence is externalized into topic-based token structures. As a result, coordination patterns remain static regardless of agent population, while the semantic layer scales independently via shared topic distributions. This architectural separation ensures that system growth does not translate into state-space growth. Comparison with LLM Chaining ArchitecturesWhile TB-CSPN achieves scalable coordination through shared semantics and formal rule processing, LLM chaining frameworks like LangGraph exhibit linear scaling behavior and growing inefficiencies. In LangGraph, each agent (Consultant, Supervisor, Worker) typically invokes a separate LLM instance,with no shared memory or semantic interlingua. This leads to a direct multiplication of inference cost and coordination latency with each additional agent. Our experimental attempts to scale LangGraph pipelines beyond 25 agents revealed unacceptable performance degradation due to latency and memory strain. Extrapolated memory usage suggests that coordinating 100 agents would require over 200 MB--nearly 10\(\times\) TB-CSPN's measured usage. These findings reinforce the central design insight behind TB-CSPN: scalable agent coordination requires a clean architectural separation between semantic processing (handled by LLMs) and formal coordination (managed by Petri Nets). As demonstrated in Table 5 and visualized in Figure 6, TB-CSPN exhibits remarkable sub-linear scaling properties, with memory per agent decreasing down from 2.12 MB to 0.21 MB as the system scales from 10 to 100 agents. This nearly 10\(\times\) improvement directly contradicts traditional assumptions about Petri Net scalability. Figure 6: TB-CSPN Scaling Performance Analysis. Top-left: Sub-linear memory scaling demonstrates dramatic efficiency improvements (10\(\times\) reduction per agent) compared to traditional systems. Top-right: Total memory usage remains flat despite agent population growth. Bottom panels show consistent throughput and maintained reliability across all scales, validating TB-CSPN’s architectural advantages. \begin{table}
\begin{tabular}{c c c c c c} \hline \hline
**Agents** & **Tasks** & **Memory (MB)** & **Memory/Agent (MB)** & **Throughput (t/s)** & **Success Rate** \\ \hline
10 & 30 & 21.2 & 2.12 & 2.72 & 96.7\% \\
25 & 50 & 20.9 & 0.84 & 2.77 & 90.0\% \\
50 & 75 & 21.3 & 0.43 & 2.77 & 93.3\% \\
100 & 100 & 21.5 & 0.21 & 3.03 & 92.0\% \\ \hline \hline \end{tabular}
\end{table} 
Table 5: TB-CSPN Scaling Performance: Memory and Throughput Analysis. Challenging Common Scalability Assumptions: Our empirical results challenge several widely held beliefs about multi-agent system scalability:
* _State-Space Explosion Mitigation:_ Classical Petri Net systems are often assumed to suffer from state-space explosion in large deployments. TB-CSPN avoids this outcome entirely through architectural separation, achieving nearly an order-of-magnitude improvement in memory efficiency per agent.