-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy patharchitecture.html
More file actions
1596 lines (1519 loc) · 104 KB
/
architecture.html
File metadata and controls
1596 lines (1519 loc) · 104 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Architecture Guide | MAFBench</title>
<meta http-equiv="refresh" content="0; url=architecture/index.html">
<script>
window.location.href = 'architecture/index.html';
</script>
</head>
<body class="bg-white">
<p>Redirecting to <a href="architecture/index.html">Architecture Guide</a>...</p>
<!-- Navigation -->
<nav id="navbar" class="fixed top-0 w-full bg-white/95 backdrop-blur-sm shadow-sm z-50">
<div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
<div class="flex justify-between items-center h-16">
<div class="flex items-center">
<a href="index.html" class="text-2xl font-bold text-indigo-600">MAFBench</a>
</div>
<div class="hidden md:flex space-x-8">
<a href="index.html" class="text-gray-600 hover:text-indigo-600">Home</a>
<a href="design.html" class="text-gray-600 hover:text-indigo-600">Why Design Matters</a>
<a href="architecture.html" class="text-gray-900 font-medium hover:text-indigo-600">Architecture Guide</a>
<a href="results.html" class="text-gray-600 hover:text-indigo-600">Results</a>
<a href="mafbench.html" class="text-gray-600 hover:text-indigo-600">MAFBench</a>
<a href="paper.html" class="text-gray-600 hover:text-indigo-600">Paper & Code</a>
<a href="about.html" class="text-gray-600 hover:text-indigo-600">About</a>
</div>
<button id="mobile-menu-btn" class="md:hidden text-gray-600">
<i class="fas fa-bars text-xl"></i>
</button>
</div>
</div>
<div id="mobile-menu" class="hidden md:hidden bg-white border-t">
<div class="px-4 py-4 space-y-3">
<a href="index.html" class="block text-gray-600">Home</a>
<a href="design.html" class="block text-gray-600">Why Design Matters</a>
<a href="architecture.html" class="block text-gray-900 font-medium">Architecture Guide</a>
<a href="results.html" class="block text-gray-600">Results</a>
<a href="mafbench.html" class="block text-gray-600">MAFBench</a>
<a href="paper.html" class="block text-gray-600">Paper & Code</a>
<a href="about.html" class="block text-gray-600">About</a>
</div>
</div>
</nav>
<!-- Hero Section -->
<section class="pt-32 pb-16 px-4 sm:px-6 lg:px-8 bg-white border-b border-gray-200">
<div class="max-w-4xl mx-auto">
<h1 class="text-5xl md:text-6xl font-bold text-gray-900 mb-6">
Architecture Guide
</h1>
<p class="text-lg text-gray-700 leading-relaxed">
This guide systematically explains the architectural dimensions that define multi-agent LLM systems.
Each dimension represents a fundamental design choice that impacts performance, scalability, and
coordination capability. Understanding these dimensions enables informed framework selection and
system design.
</p>
</div>
</section>
<!-- What Are Agents and Frameworks -->
<section class="py-20 px-4 sm:px-6 lg:px-8 bg-white border-b border-gray-200">
<div class="max-w-6xl mx-auto">
<h2 class="text-4xl font-bold text-gray-900 mb-6">What Are Agents and Frameworks?</h2>
<div class="space-y-6 text-lg text-gray-700 leading-relaxed">
<p>
<strong>An agent</strong> is an autonomous system that can observe its environment, make decisions,
and take actions. In multi-agent LLM systems, each agent uses a large language model to reason
about what to do. Agents have roles (what they specialize in), objectives (what they're trying
to achieve), tools they can use, and memory to store information.
</p>
<p>
<strong>A multi-agent framework</strong> is the system that orchestrates multiple agents, manages
how they communicate, and controls how they execute tasks. The framework defines the rules:
how agents are scheduled, how they share information, and how they coordinate. Different
frameworks make different architectural choices, which dramatically affect performance.
</p>
</div>
</div>
</section>
<!-- Architectural Paradigms Overview -->
<section class="py-20 px-4 sm:px-6 lg:px-8 bg-white">
<div class="max-w-6xl mx-auto">
<h2 class="text-4xl font-bold text-gray-900 mb-6">Architectural Paradigms</h2>
<p class="text-lg text-gray-700 mb-8 leading-relaxed">
Multi-agent LLM frameworks fall into three main paradigms based on how they structure execution
and agent interactions. Each paradigm makes different trade-offs between control, flexibility,
and performance. Understanding these paradigms helps you choose the right framework for your needs.
</p>
<!-- Graph-Based Frameworks -->
<div class="mb-16 pb-16 border-b border-gray-200">
<h3 class="text-3xl font-semibold text-gray-900 mb-4">Graph-Based Frameworks</h3>
<p class="text-lg text-gray-700 mb-6 leading-relaxed">
Graph-based frameworks model your multi-agent system as a workflow graph. Think of it like a
flowchart: nodes represent agents or processing steps, and edges define how information and
control flow between them. Execution follows this predefined structure step by step.
</p>
<p class="text-lg text-gray-700 mb-6 leading-relaxed">
<strong>How it works:</strong> You design the graph upfront, defining which agents run when
and in what order. The framework enforces this structure at runtime, making execution predictable
and transparent. Agents communicate only along the edges you've defined in the graph.
</p>
<p class="text-lg text-gray-700 mb-6 leading-relaxed">
<strong>Best for:</strong> Tasks with clear, deterministic workflows where you need predictable
execution order and transparent debugging. Examples include <a href="https://www.langchain.com/langgraph" target="_blank" class="text-indigo-600 hover:text-indigo-700 hover:underline">LangGraph</a>,
<a href="https://n8n.io/" target="_blank" class="text-indigo-600 hover:text-indigo-700 hover:underline">n8n</a>, and
<a href="https://www.langflow.org/" target="_blank" class="text-indigo-600 hover:text-indigo-700 hover:underline">Langflow</a>.
</p>
<div class="grid md:grid-cols-2 gap-8">
<div>
<p class="text-lg text-gray-700 leading-relaxed">
Graph-based frameworks enforce a workflow structure where execution follows predefined
graph edges. This makes the control flow deterministic and transparent, but requires
upfront design of the entire workflow.
</p>
</div>
<div class="bg-white border border-gray-300 rounded-lg overflow-hidden">
<table class="w-full text-xs">
<thead class="bg-gray-100">
<tr>
<th class="px-4 py-2 text-left font-semibold text-gray-900 border-b border-gray-300">What it enforces</th>
<th class="px-4 py-2 text-left font-semibold text-gray-900 border-b border-gray-300">What you can control</th>
</tr>
</thead>
<tbody class="divide-y divide-gray-200">
<tr>
<td class="px-4 py-2 text-gray-700">Workflow structure</td>
<td class="px-4 py-2 text-gray-700">Node definitions, edge conditions</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">Execution follows edges</td>
<td class="px-4 py-2 text-gray-700">Memory structure, data flow</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">Communication along edges</td>
<td class="px-4 py-2 text-gray-700">Agent logic, tools, planning</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>
<!-- Role-Based Frameworks -->
<div class="mb-16 pb-16 border-b border-gray-200">
<h3 class="text-3xl font-semibold text-gray-900 mb-4">Role-Based Frameworks</h3>
<p class="text-lg text-gray-700 mb-6 leading-relaxed">
Role-based frameworks organize agents around job descriptions. Each agent has a role (like
"researcher" or "writer") that defines what they do, what tools they can use, and how they
interact with others. Instead of a fixed workflow, coordination emerges from agents following
their roles and delegating tasks.
</p>
<p class="text-lg text-gray-700 mb-6 leading-relaxed">
<strong>How it works:</strong> You define roles and assign agents to them. Agents use their
role descriptions to decide what to do and when to hand off work to other agents. The framework
handles the coordination, but the exact flow isn't predetermined—it depends on how agents
reason about the task.
</p>
<p class="text-lg text-gray-700 mb-6 leading-relaxed">
<strong>Best for:</strong> Flexible tasks where you want agents to adapt their coordination
based on the problem. Examples include <a href="https://www.crewai.com/" target="_blank" class="text-indigo-600 hover:text-indigo-700 hover:underline">CrewAI</a>,
<a href="https://microsoft.github.io/autogen/" target="_blank" class="text-indigo-600 hover:text-indigo-700 hover:underline">AutoGen</a>,
<a href="https://openai.github.io/openai-agents-python/" target="_blank" class="text-indigo-600 hover:text-indigo-700 hover:underline">OpenAI Agents</a>,
<a href="https://github.com/agno-ai/agno" target="_blank" class="text-indigo-600 hover:text-indigo-700 hover:underline">Agno</a>, and
<a href="https://github.com/xlang-ai/OpenAgents" target="_blank" class="text-indigo-600 hover:text-indigo-700 hover:underline">OpenAgents</a>.
</p>
<div class="grid md:grid-cols-2 gap-8">
<div>
<p class="text-lg text-gray-700 leading-relaxed">
Role-based frameworks enforce agent role abstraction and role-conditioned interactions.
This provides flexibility in coordination while maintaining structured communication
patterns. Designers control role definitions, execution order, and tool access.
</p>
</div>
<div class="bg-white border border-gray-300 rounded-lg overflow-hidden">
<table class="w-full text-xs">
<thead class="bg-gray-100">
<tr>
<th class="px-4 py-2 text-left font-semibold text-gray-900 border-b border-gray-300">What it enforces</th>
<th class="px-4 py-2 text-left font-semibold text-gray-900 border-b border-gray-300">What you can control</th>
</tr>
</thead>
<tbody class="divide-y divide-gray-200">
<tr>
<td class="px-4 py-2 text-gray-700">Role abstraction</td>
<td class="px-4 py-2 text-gray-700">Role definitions</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">Role-conditioned interactions</td>
<td class="px-4 py-2 text-gray-700">Execution order, parallelism</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">Structured messages</td>
<td class="px-4 py-2 text-gray-700">Tool access, planning, memory</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>
<!-- GABM Frameworks -->
<div class="mb-16">
<h3 class="text-3xl font-semibold text-gray-900 mb-4">GABM Frameworks (Generative Agent-Based Modeling)</h3>
<p class="text-lg text-gray-700 mb-6 leading-relaxed">
GABM frameworks treat multi-agent systems like simulations. Agents exist in a shared environment
and interact with it over time. Instead of direct agent-to-agent communication, coordination
happens indirectly through the environment state. Think of it like a virtual world where agents
observe, act, and influence what happens next.
</p>
<p class="text-lg text-gray-700 mb-6 leading-relaxed">
<strong>How it works:</strong> The framework maintains an environment state that all agents can
observe and modify. Each time step, agents see the current state, decide what to do, and their
actions update the environment. Coordination emerges from how agents respond to the shared
world state, not from explicit communication.
</p>
<p class="text-lg text-gray-700 mb-6 leading-relaxed">
<strong>Best for:</strong> Simulating complex systems where you want emergent behavior from
agent-environment interactions. Examples include <a href="https://github.com/google-deepmind/concordia" target="_blank" class="text-indigo-600 hover:text-indigo-700 hover:underline">DeepMind Concordia</a>.
</p>
<div class="grid md:grid-cols-2 gap-8">
<div>
<p class="text-lg text-gray-700 leading-relaxed">
GABM frameworks enforce a time-step simulation model with environment-mediated interactions.
This creates emergent coordination but requires careful design of environment rules and
observation models. Designers control agent behaviors and how the environment evolves.
</p>
</div>
<div class="bg-white border border-gray-300 rounded-lg overflow-hidden">
<table class="w-full text-xs">
<thead class="bg-gray-100">
<tr>
<th class="px-4 py-2 text-left font-semibold text-gray-900 border-b border-gray-300">What it enforces</th>
<th class="px-4 py-2 text-left font-semibold text-gray-900 border-b border-gray-300">What you can control</th>
</tr>
</thead>
<tbody class="divide-y divide-gray-200">
<tr>
<td class="px-4 py-2 text-gray-700">Time-step model</td>
<td class="px-4 py-2 text-gray-700">Agent behaviors</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">Environment-mediated</td>
<td class="px-4 py-2 text-gray-700">Environment rules, updates</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">No direct communication</td>
<td class="px-4 py-2 text-gray-700">Observations, action effects</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>
<!-- Summary Table -->
<div class="bg-white border border-gray-300 rounded-lg overflow-hidden">
<table class="w-full text-sm">
<thead class="bg-gray-100">
<tr>
<th class="px-6 py-3 text-left font-semibold text-gray-900 border-b border-gray-300">Paradigm</th>
<th class="px-6 py-3 text-left font-semibold text-gray-900 border-b border-gray-300">Execution model</th>
<th class="px-6 py-3 text-left font-semibold text-gray-900 border-b border-gray-300">Coordination style</th>
</tr>
</thead>
<tbody class="divide-y divide-gray-200">
<tr>
<td class="px-6 py-4 text-gray-900">Graph-based</td>
<td class="px-6 py-4 text-gray-700">Follows predefined workflow graph</td>
<td class="px-6 py-4 text-gray-700">Determined at design time</td>
</tr>
<tr>
<td class="px-6 py-4 text-gray-900">Role-based</td>
<td class="px-6 py-4 text-gray-700">Role-conditioned reasoning and delegation</td>
<td class="px-6 py-4 text-gray-700">Emerges from role interactions</td>
</tr>
<tr>
<td class="px-6 py-4 text-gray-900">GABM</td>
<td class="px-6 py-4 text-gray-700">Time-step simulation with environment</td>
<td class="px-6 py-4 text-gray-700">Mediated through shared environment state</td>
</tr>
</tbody>
</table>
</div>
</div>
</section>
<!-- Design Dimensions Overview -->
<section class="py-20 px-4 sm:px-6 lg:px-8 bg-gray-50">
<div class="max-w-6xl mx-auto">
<h2 class="text-4xl font-bold text-gray-900 mb-6">Design Dimensions</h2>
<p class="text-lg text-gray-700 mb-8 leading-relaxed">
These dimensions define multi-agent system architecture. Each dimension represents a fundamental
design choice that can be fixed by the framework paradigm or configured by the system designer.
We organize them into three categories: how individual agents work, how agents interact, and
how the system environment is structured.
</p>
<div class="grid md:grid-cols-3 gap-6 mt-8">
<div class="bg-white border border-gray-300 rounded-lg p-6">
<h3 class="text-xl font-semibold text-gray-900 mb-3">Single-Agent Characteristics</h3>
<ul class="space-y-2 text-sm text-gray-700">
<li>• Behavioral Specification</li>
<li>• Storage Architecture</li>
<li>• Tool Execution</li>
</ul>
</div>
<div class="bg-white border border-gray-300 rounded-lg p-6">
<h3 class="text-xl font-semibold text-gray-900 mb-3">Multi-Agent Characteristics</h3>
<ul class="space-y-2 text-sm text-gray-700">
<li>• Network Topology</li>
<li>• Communication Pattern</li>
<li>• Collaboration</li>
</ul>
</div>
<div class="bg-white border border-gray-300 rounded-lg p-6">
<h3 class="text-xl font-semibold text-gray-900 mb-3">Environment</h3>
<ul class="space-y-2 text-sm text-gray-700">
<li>• World State</li>
<li>• Grounded Variables</li>
</ul>
</div>
</div>
</div>
</section>
<!-- Single-Agent Characteristics -->
<section id="single-agent" class="py-20 px-4 sm:px-6 lg:px-8 bg-white border-t border-gray-200">
<div class="max-w-6xl mx-auto">
<h2 class="text-4xl font-bold text-gray-900 mb-8">Single-Agent Characteristics</h2>
<p class="text-lg text-gray-700 mb-12 leading-relaxed">
These dimensions control how individual agents are designed and how they behave. They determine
what agents know, how they think, and what actions they can take.
</p>
<!-- Behavioral Specification -->
<div class="mb-16 pb-16 border-b border-gray-200">
<h3 class="text-3xl font-semibold text-gray-900 mb-6">Behavioral Specification</h3>
<p class="text-lg text-gray-700 mb-6 leading-relaxed">
This dimension controls how you tell agents what to do. You can either hardcode their behavior
in the workflow, give them role descriptions that guide their reasoning, or let behavior emerge
from how they interact with the environment.
</p>
<div class="grid md:grid-cols-2 gap-8 mb-8">
<div>
<h4 class="text-xl font-semibold text-gray-900 mb-4">How frameworks handle this</h4>
<p class="text-lg text-gray-700 leading-relaxed mb-4">
<strong>Graph-based frameworks</strong> encode roles, goals, and plans directly in the
workflow structure. Behavior is determined by the graph logic, not by explicit role
descriptions. If you want an agent to plan, you code that planning step into the graph.
</p>
<p class="text-lg text-gray-700 leading-relaxed mb-4">
<strong>Role-based frameworks</strong> make roles and goals explicit. You write role
descriptions that condition how the LLM reasons. Planning happens through natural language
plan generation, manager-worker coordination, or iterative refinement—not rigid sequences.
</p>
<p class="text-lg text-gray-700 leading-relaxed">
<strong>GABM frameworks</strong> treat roles, goals, and plans as optional. Behavior
emerges from agents repeatedly observing the environment and taking actions, rather than
following explicit instructions.
</p>
</div>
<div class="bg-white border border-gray-300 rounded-lg overflow-hidden">
<table class="w-full text-xs">
<thead class="bg-gray-100">
<tr>
<th class="px-4 py-2 text-left font-semibold text-gray-900 border-b border-gray-300">Feature</th>
<th class="px-4 py-2 text-center font-semibold text-gray-900 border-b border-gray-300">Graph</th>
<th class="px-4 py-2 text-center font-semibold text-gray-900 border-b border-gray-300">Role</th>
<th class="px-4 py-2 text-center font-semibold text-gray-900 border-b border-gray-300">GABM</th>
</tr>
</thead>
<tbody class="divide-y divide-gray-200">
<tr>
<td class="px-4 py-2 text-gray-700">Role</td>
<td class="px-4 py-2 text-center text-gray-700">Implicit</td>
<td class="px-4 py-2 text-center text-gray-700">Explicit</td>
<td class="px-4 py-2 text-center text-gray-700">Optional</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">Goal</td>
<td class="px-4 py-2 text-center text-gray-700">Graph-determined</td>
<td class="px-4 py-2 text-center text-gray-700">First-class object</td>
<td class="px-4 py-2 text-center text-gray-700">Environment-driven</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">Planning</td>
<td class="px-4 py-2 text-center text-gray-700">Embedded in graph</td>
<td class="px-4 py-2 text-center text-gray-700">Pre-task or manager-worker</td>
<td class="px-4 py-2 text-center text-gray-700">Optional</td>
</tr>
</tbody>
</table>
</div>
</div>
<p class="text-lg text-gray-700 leading-relaxed">
<strong>Trade-off:</strong> Graph-based gives you deterministic control but less flexibility.
Role-based enables adaptive reasoning but requires careful role design. GABM enables emergent
behavior but reduces direct control.
</p>
</div>
<!-- Storage Architecture -->
<div class="mb-16 pb-16 border-b border-gray-200">
<h3 class="text-3xl font-semibold text-gray-900 mb-6">Storage Architecture</h3>
<p class="text-lg text-gray-700 mb-6 leading-relaxed">
This dimension controls how agents remember things. Frameworks provide different types of memory:
long-term memory (LTM) for persistent knowledge, short-term memory (STM) for recent interactions,
entity memory (EM) for structured facts, working memory (WM) for active context, and external
knowledge (EK) for attached documents.
</p>
<div class="grid md:grid-cols-2 gap-8 mb-8">
<div>
<h4 class="text-xl font-semibold text-gray-900 mb-4">How frameworks handle this</h4>
<p class="text-lg text-gray-700 leading-relaxed mb-4">
<strong>Graph-based frameworks</strong> primarily use retrieval-based long-term memory
with bounded short-term execution state. Entity memory, working memory, and external
knowledge must be managed manually by developers.
</p>
<p class="text-lg text-gray-700 leading-relaxed mb-4">
<strong>Role-based frameworks</strong> follow a similar retrieval-centric design but
may support structured entity memory via embedding-based retrieval. They also allow
explicit attachment of external knowledge like documents or files.
</p>
<p class="text-lg text-gray-700 leading-relaxed">
<strong>GABM frameworks</strong> centralize memory at the environment level. They
maintain long-term textual memory accessed by the LLM and update state via developer-defined
transition functions, rather than short-term context accumulation.
</p>
</div>
<div class="bg-white border border-gray-300 rounded-lg overflow-hidden">
<table class="w-full text-xs">
<thead class="bg-gray-100">
<tr>
<th class="px-4 py-2 text-left font-semibold text-gray-900 border-b border-gray-300">Memory Type</th>
<th class="px-4 py-2 text-center font-semibold text-gray-900 border-b border-gray-300">Graph</th>
<th class="px-4 py-2 text-center font-semibold text-gray-900 border-b border-gray-300">Role</th>
<th class="px-4 py-2 text-center font-semibold text-gray-900 border-b border-gray-300">GABM</th>
</tr>
</thead>
<tbody class="divide-y divide-gray-200">
<tr>
<td class="px-4 py-2 text-gray-700">LTM</td>
<td class="px-4 py-2 text-center text-gray-700">✓ Retrieval-based</td>
<td class="px-4 py-2 text-center text-gray-700">✓ Retrieval-based</td>
<td class="px-4 py-2 text-center text-gray-700">✓ LLM-queried</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">STM</td>
<td class="px-4 py-2 text-center text-gray-700">✓ Conversation/state</td>
<td class="px-4 py-2 text-center text-gray-700">✓ RAG-based context</td>
<td class="px-4 py-2 text-center text-gray-700">✗ Not native</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">EM</td>
<td class="px-4 py-2 text-center text-gray-700">✗ Manual</td>
<td class="px-4 py-2 text-center text-gray-700">✓ Optional structured</td>
<td class="px-4 py-2 text-center text-gray-700">✗ Not native</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">WM</td>
<td class="px-4 py-2 text-center text-gray-700">✗ Developer-managed</td>
<td class="px-4 py-2 text-center text-gray-700">✗ Implicit</td>
<td class="px-4 py-2 text-center text-gray-700">✓ Derived from LTM</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">EK</td>
<td class="px-4 py-2 text-center text-gray-700">✗ Not native</td>
<td class="px-4 py-2 text-center text-gray-700">✓ Attachable</td>
<td class="px-4 py-2 text-center text-gray-700">✗ Not native</td>
</tr>
</tbody>
</table>
</div>
</div>
<p class="text-lg text-gray-700 leading-relaxed">
<strong>Trade-off:</strong> Retrieval-based memory scales better but requires indexing. Accumulation
is simpler but costs grow exponentially. Centralized environment memory enables persistent state
evolution but limits per-agent flexibility.
</p>
</div>
<!-- Tool Execution -->
<div class="mb-16">
<h3 class="text-3xl font-semibold text-gray-900 mb-6">Tool Execution Model</h3>
<p class="text-lg text-gray-700 mb-6 leading-relaxed">
This dimension determines where tool execution authority lives and how tools are invoked. Tools
can be bound to workflow nodes, attached to agent roles, or routed through an environment controller.
</p>
<div class="grid md:grid-cols-2 gap-8 mb-8">
<div>
<h4 class="text-xl font-semibold text-gray-900 mb-4">How frameworks handle this</h4>
<p class="text-lg text-gray-700 leading-relaxed mb-4">
<strong>Graph-based frameworks</strong> integrate tools in two ways: as explicit workflow
nodes where execution is fixed by control-flow logic, or as agent-callable functions
constrained by the graph structure.
</p>
<p class="text-lg text-gray-700 leading-relaxed mb-4">
<strong>Role-based frameworks</strong> bind tools to agent roles and task context. Agents
can dynamically select tools during reasoning, but access is constrained by orchestration
semantics.
</p>
<p class="text-lg text-gray-700 leading-relaxed">
<strong>GABM frameworks</strong> remove direct tool access from agents. All external
actions route through an environment controller that interprets agent intentions and
updates global state.
</p>
</div>
<div class="bg-white border border-gray-300 rounded-lg overflow-hidden">
<table class="w-full text-xs">
<thead class="bg-gray-100">
<tr>
<th class="px-4 py-2 text-left font-semibold text-gray-900 border-b border-gray-300">Framework</th>
<th class="px-4 py-2 text-left font-semibold text-gray-900 border-b border-gray-300">Tool Model</th>
</tr>
</thead>
<tbody class="divide-y divide-gray-200">
<tr>
<td class="px-4 py-2 text-gray-700">Graph-based</td>
<td class="px-4 py-2 text-gray-700">Agent-bound or graph nodes</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">Role-based</td>
<td class="px-4 py-2 text-gray-700">Agent-bound, role-constrained</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">GABM</td>
<td class="px-4 py-2 text-gray-700">Environment-executed</td>
</tr>
</tbody>
</table>
</div>
</div>
<p class="text-lg text-gray-700 leading-relaxed">
<strong>Trade-off:</strong> Procedural invocation offers strict control and stable costs.
Role-conditioned access enables flexible problem solving with weaker guarantees. Environment-mediated
execution supports persistent state evolution while limiting direct agent control.
</p>
</div>
</div>
</section>
<!-- Multi-Agent Characteristics -->
<section id="multi-agent" class="py-20 px-4 sm:px-6 lg:px-8 bg-gray-50 border-t border-gray-200">
<div class="max-w-6xl mx-auto">
<h2 class="text-4xl font-bold text-gray-900 mb-8">Multi-Agent Characteristics</h2>
<p class="text-lg text-gray-700 mb-12 leading-relaxed">
These dimensions control how agents interact with each other. They determine who can talk to whom,
how information flows, and whether agents can collaborate on decisions.
</p>
<!-- Network Topology -->
<div class="mb-16 pb-16 border-b border-gray-200">
<h3 class="text-3xl font-semibold text-gray-900 mb-6">Network Topology</h3>
<p class="text-lg text-gray-700 mb-6 leading-relaxed">
This dimension controls how agents are connected and which coordination patterns are possible.
The topology shapes what information can flow between agents and how quickly coordination happens.
</p>
<div class="mb-8">
<h4 class="text-xl font-semibold text-gray-900 mb-4">How frameworks handle this</h4>
<div class="grid md:grid-cols-3 gap-6 mb-8">
<div>
<p class="text-lg text-gray-700 leading-relaxed mb-4">
<strong>Graph-based frameworks</strong> let you define explicit topologies as directed
graphs at design time. You can create hierarchical, peer-to-peer, or cyclic structures,
but the topology stays fixed during execution.
</p>
</div>
<div>
<p class="text-lg text-gray-700 leading-relaxed mb-4">
<strong>Role-based frameworks</strong> create topology implicitly through task decomposition
and role assignments. This typically results in sequential pipelines or manager-worker
hierarchies with limited lateral interaction.
</p>
</div>
<div>
<p class="text-lg text-gray-700 leading-relaxed">
<strong>GABM frameworks</strong> centralize interaction through an environment controller
(Game Master), enforcing a star topology where agents only interact with the environment,
not directly with each other.
</p>
</div>
</div>
</div>
<div class="bg-white border border-gray-300 rounded-lg p-8 mb-8">
<h4 class="text-lg font-semibold text-gray-900 mb-6 text-center">Network Topology Examples</h4>
<div class="grid md:grid-cols-3 gap-8">
<!-- Graph-based: Supervisor -->
<div class="text-center">
<p class="text-sm font-semibold text-gray-900 mb-3">Graph-based: Supervisor</p>
<div class="flex justify-center mb-2">
<svg width="120" height="100" class="border border-gray-300 rounded bg-gray-50">
<!-- Level 1: Root -->
<circle cx="60" cy="15" r="8" fill="#4F46E5" stroke="#312E81" stroke-width="2"/>
<text x="55" y="19" font-size="10" fill="white" font-weight="bold">S</text>
<!-- Level 2: Two nodes -->
<circle cx="30" cy="45" r="7" fill="#6366F1" stroke="#4338CA" stroke-width="1.5"/>
<text x="26" y="49" font-size="9" fill="white" font-weight="bold">A1</text>
<circle cx="90" cy="45" r="7" fill="#6366F1" stroke="#4338CA" stroke-width="1.5"/>
<text x="86" y="49" font-size="9" fill="white" font-weight="bold">A2</text>
<!-- Level 3: Four nodes -->
<circle cx="15" cy="75" r="6" fill="#818CF8" stroke="#6366F1" stroke-width="1"/>
<text x="12" y="79" font-size="8" fill="white">a1</text>
<circle cx="35" cy="75" r="6" fill="#818CF8" stroke="#6366F1" stroke-width="1"/>
<text x="32" y="79" font-size="8" fill="white">a2</text>
<circle cx="75" cy="75" r="6" fill="#818CF8" stroke="#6366F1" stroke-width="1"/>
<text x="72" y="79" font-size="8" fill="white">a3</text>
<circle cx="95" cy="75" r="6" fill="#818CF8" stroke="#6366F1" stroke-width="1"/>
<text x="92" y="79" font-size="8" fill="white">a4</text>
<!-- Edges -->
<line x1="60" y1="23" x2="30" y2="38" stroke="#6B7280" stroke-width="2" marker-end="url(#arrowhead)"/>
<line x1="60" y1="23" x2="90" y2="38" stroke="#6B7280" stroke-width="2" marker-end="url(#arrowhead)"/>
<line x1="30" y1="52" x2="15" y2="69" stroke="#6B7280" stroke-width="1.5" marker-end="url(#arrowhead)"/>
<line x1="30" y1="52" x2="35" y2="69" stroke="#6B7280" stroke-width="1.5" marker-end="url(#arrowhead)"/>
<line x1="90" y1="52" x2="75" y2="69" stroke="#6B7280" stroke-width="1.5" marker-end="url(#arrowhead)"/>
<line x1="90" y1="52" x2="95" y2="69" stroke="#6B7280" stroke-width="1.5" marker-end="url(#arrowhead)"/>
<!-- Arrow marker definition -->
<defs>
<marker id="arrowhead" markerWidth="6" markerHeight="6" refX="5" refY="3" orient="auto">
<polygon points="0 0, 6 3, 0 6" fill="#6B7280"/>
</marker>
</defs>
</svg>
</div>
<p class="text-xs text-gray-600">Hierarchical tree structure</p>
</div>
<!-- Graph-based: Network -->
<div class="text-center">
<p class="text-sm font-semibold text-gray-900 mb-3">Graph-based: Network</p>
<div class="flex justify-center mb-2">
<svg width="100" height="100" class="border border-gray-300 rounded bg-gray-50">
<!-- Four nodes in square -->
<circle cx="30" cy="30" r="8" fill="#4F46E5" stroke="#312E81" stroke-width="2"/>
<text x="25" y="34" font-size="10" fill="white" font-weight="bold">A1</text>
<circle cx="70" cy="30" r="8" fill="#4F46E5" stroke="#312E81" stroke-width="2"/>
<text x="65" y="34" font-size="10" fill="white" font-weight="bold">A2</text>
<circle cx="30" cy="70" r="8" fill="#4F46E5" stroke="#312E81" stroke-width="2"/>
<text x="25" y="74" font-size="10" fill="white" font-weight="bold">A3</text>
<circle cx="70" cy="70" r="8" fill="#4F46E5" stroke="#312E81" stroke-width="2"/>
<text x="65" y="74" font-size="10" fill="white" font-weight="bold">A4</text>
<!-- All edges (fully connected) -->
<line x1="30" y1="30" x2="70" y2="30" stroke="#6B7280" stroke-width="1.5"/>
<line x1="30" y1="30" x2="30" y2="70" stroke="#6B7280" stroke-width="1.5"/>
<line x1="30" y1="30" x2="70" y2="70" stroke="#6B7280" stroke-width="1.5"/>
<line x1="70" y1="30" x2="70" y2="70" stroke="#6B7280" stroke-width="1.5"/>
<line x1="70" y1="30" x2="30" y2="70" stroke="#6B7280" stroke-width="1.5"/>
<line x1="30" y1="70" x2="70" y2="70" stroke="#6B7280" stroke-width="1.5"/>
</svg>
</div>
<p class="text-xs text-gray-600">Fully connected graph</p>
</div>
<!-- Role-based: Task hierarchy -->
<div class="text-center">
<p class="text-sm font-semibold text-gray-900 mb-3">Role-based: Task hierarchy</p>
<div class="flex justify-center mb-2">
<svg width="120" height="110" class="border border-gray-300 rounded bg-gray-50">
<!-- Orchestrator at top -->
<rect x="45" y="10" width="30" height="18" rx="3" fill="#10B981" stroke="#059669" stroke-width="2"/>
<text x="52" y="23" font-size="11" fill="white" font-weight="bold">Orch</text>
<!-- Three agents -->
<circle cx="25" cy="50" r="9" fill="#34D399" stroke="#10B981" stroke-width="1.5"/>
<text x="19" y="55" font-size="9" fill="white" font-weight="bold">Agent</text>
<circle cx="60" cy="50" r="9" fill="#34D399" stroke="#10B981" stroke-width="1.5"/>
<text x="54" y="55" font-size="9" fill="white" font-weight="bold">Agent</text>
<circle cx="95" cy="50" r="9" fill="#34D399" stroke="#10B981" stroke-width="1.5"/>
<text x="89" y="55" font-size="9" fill="white" font-weight="bold">Agent</text>
<!-- Two tasks connected to middle agent -->
<rect x="20" y="80" width="20" height="16" rx="2" fill="#6EE7B7" stroke="#34D399" stroke-width="1"/>
<text x="25" y="91" font-size="8" fill="#065F46" font-weight="bold">Task</text>
<rect x="50" y="80" width="20" height="16" rx="2" fill="#6EE7B7" stroke="#34D399" stroke-width="1"/>
<text x="55" y="91" font-size="8" fill="#065F46" font-weight="bold">Task</text>
<!-- Edges -->
<line x1="60" y1="28" x2="25" y2="41" stroke="#6B7280" stroke-width="2" marker-end="url(#arrowhead2)"/>
<line x1="60" y1="28" x2="60" y2="41" stroke="#6B7280" stroke-width="2" marker-end="url(#arrowhead2)"/>
<line x1="60" y1="28" x2="95" y2="41" stroke="#6B7280" stroke-width="2" marker-end="url(#arrowhead2)"/>
<line x1="60" y1="59" x2="30" y2="80" stroke="#6B7280" stroke-width="1.5" marker-end="url(#arrowhead2)"/>
<line x1="60" y1="59" x2="60" y2="80" stroke="#6B7280" stroke-width="1.5" marker-end="url(#arrowhead2)"/>
<!-- Arrow marker definition -->
<defs>
<marker id="arrowhead2" markerWidth="6" markerHeight="6" refX="5" refY="3" orient="auto">
<polygon points="0 0, 6 3, 0 6" fill="#6B7280"/>
</marker>
</defs>
</svg>
</div>
<p class="text-xs text-gray-600">Orchestrator → Agents → Tasks</p>
</div>
</div>
<!-- GABM Star topology - full width -->
<div class="mt-8 pt-8 border-t border-gray-200">
<div class="text-center">
<p class="text-sm font-semibold text-gray-900 mb-4">GABM: Star topology</p>
<div class="flex justify-center">
<svg width="140" height="140" class="border border-gray-300 rounded bg-gray-50">
<!-- Central Game Master -->
<circle cx="70" cy="70" r="16" fill="#F59E0B" stroke="#D97706" stroke-width="2.5"/>
<text x="58" y="76" font-size="12" fill="white" font-weight="bold">GM</text>
<!-- Four agents around GM -->
<circle cx="70" cy="25" r="10" fill="#FBBF24" stroke="#F59E0B" stroke-width="2"/>
<text x="66" y="30" font-size="10" fill="white" font-weight="bold">a</text>
<circle cx="115" cy="70" r="10" fill="#FBBF24" stroke="#F59E0B" stroke-width="2"/>
<text x="111" y="75" font-size="10" fill="white" font-weight="bold">a</text>
<circle cx="70" cy="115" r="10" fill="#FBBF24" stroke="#F59E0B" stroke-width="2"/>
<text x="66" y="120" font-size="10" fill="white" font-weight="bold">a</text>
<circle cx="25" cy="70" r="10" fill="#FBBF24" stroke="#F59E0B" stroke-width="2"/>
<text x="21" y="75" font-size="10" fill="white" font-weight="bold">a</text>
<!-- Bidirectional edges (shown as double lines) -->
<line x1="70" y1="54" x2="70" y2="35" stroke="#6B7280" stroke-width="2" marker-end="url(#arrowhead3)"/>
<line x1="70" y1="54" x2="70" y2="35" stroke="#6B7280" stroke-width="2" stroke-dasharray="2,2" opacity="0.5"/>
<line x1="86" y1="70" x2="105" y2="70" stroke="#6B7280" stroke-width="2" marker-end="url(#arrowhead3)"/>
<line x1="86" y1="70" x2="105" y2="70" stroke="#6B7280" stroke-width="2" stroke-dasharray="2,2" opacity="0.5"/>
<line x1="70" y1="86" x2="70" y2="105" stroke="#6B7280" stroke-width="2" marker-end="url(#arrowhead3)"/>
<line x1="70" y1="86" x2="70" y2="105" stroke="#6B7280" stroke-width="2" stroke-dasharray="2,2" opacity="0.5"/>
<line x1="54" y1="70" x2="35" y2="70" stroke="#6B7280" stroke-width="2" marker-end="url(#arrowhead3)"/>
<line x1="54" y1="70" x2="35" y2="70" stroke="#6B7280" stroke-width="2" stroke-dasharray="2,2" opacity="0.5"/>
<!-- Arrow marker definition -->
<defs>
<marker id="arrowhead3" markerWidth="6" markerHeight="6" refX="5" refY="3" orient="auto">
<polygon points="0 0, 6 3, 0 6" fill="#6B7280"/>
</marker>
</defs>
</svg>
</div>
<p class="text-xs text-gray-600 mt-2">All agents connect only to Game Master (GM)</p>
</div>
</div>
</div>
<div class="bg-white border border-gray-300 rounded-lg overflow-hidden">
<table class="w-full text-xs">
<thead class="bg-gray-100">
<tr>
<th class="px-4 py-2 text-left font-semibold text-gray-900 border-b border-gray-300">Framework</th>
<th class="px-4 py-2 text-left font-semibold text-gray-900 border-b border-gray-300">Topology</th>
</tr>
</thead>
<tbody class="divide-y divide-gray-200">
<tr>
<td class="px-4 py-2 text-gray-700">Graph-based</td>
<td class="px-4 py-2 text-gray-700">Flexible; fixed once defined</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">Role-based</td>
<td class="px-4 py-2 text-gray-700">Task hierarchy or sequence</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">GABM</td>
<td class="px-4 py-2 text-gray-700">Fixed star; GM at center</td>
</tr>
</tbody>
</table>
</div>
</div>
<!-- Communication Pattern -->
<div class="mb-16 pb-16 border-b border-gray-200">
<h3 class="text-3xl font-semibold text-gray-900 mb-6">Communication Pattern</h3>
<p class="text-lg text-gray-700 mb-6 leading-relaxed">
This dimension controls how information moves between agents. Communication can happen through
state propagation, message passing, or environment observation.
</p>
<div class="grid md:grid-cols-2 gap-8 mb-8">
<div>
<h4 class="text-xl font-semibold text-gray-900 mb-4">How frameworks handle this</h4>
<p class="text-lg text-gray-700 leading-relaxed mb-4">
<strong>Graph-based frameworks</strong> realize communication through deterministic
state propagation along predefined edges in the execution graph, rather than explicit
message passing between agents.
</p>
<p class="text-lg text-gray-700 leading-relaxed mb-4">
<strong>Role-based frameworks</strong> route communication primarily through task
assignment, intermediate result passing, and reporting mechanisms embedded in hierarchical
or sequential coordination structures.
</p>
<p class="text-lg text-gray-700 leading-relaxed">
<strong>GABM frameworks</strong> eliminate direct inter-agent messaging. All interaction
is mediated through a shared environment that aggregates agent actions and produces new
observations for subsequent reasoning.
</p>
</div>
<div class="bg-white border border-gray-300 rounded-lg overflow-hidden">
<table class="w-full text-xs">
<thead class="bg-gray-100">
<tr>
<th class="px-4 py-2 text-left font-semibold text-gray-900 border-b border-gray-300">Framework</th>
<th class="px-4 py-2 text-left font-semibold text-gray-900 border-b border-gray-300">Communication</th>
</tr>
</thead>
<tbody class="divide-y divide-gray-200">
<tr>
<td class="px-4 py-2 text-gray-700">Graph-based</td>
<td class="px-4 py-2 text-gray-700">Shared state along edges</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">Role-based</td>
<td class="px-4 py-2 text-gray-700">Task-mediated; limited peer querying</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">GABM</td>
<td class="px-4 py-2 text-gray-700">Only via GM; no peer-to-peer</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>
<!-- Collaboration -->
<div class="mb-16">
<h3 class="text-3xl font-semibold text-gray-900 mb-6">Collaboration</h3>
<p class="text-lg text-gray-700 mb-6 leading-relaxed">
This dimension captures whether frameworks provide explicit mechanisms for agents to jointly
coordinate decisions beyond procedural execution.
</p>
<div class="grid md:grid-cols-2 gap-8 mb-8">
<div>
<h4 class="text-xl font-semibold text-gray-900 mb-4">How frameworks handle this</h4>
<p class="text-lg text-gray-700 leading-relaxed mb-4">
<strong>Graph-based frameworks</strong> do not support first-class collaboration. They
rely entirely on procedural coordination enforced by predefined workflows.
</p>
<p class="text-lg text-gray-700 leading-relaxed mb-4">
<strong>Role-based frameworks</strong> enable limited forms of collaboration through
delegation, task handoff, and manager-worker coordination among role-specialized agents.
However, they generally lack support for multi-turn negotiation or collective decision-making protocols.
</p>
<p class="text-lg text-gray-700 leading-relaxed">
<strong>GABM frameworks</strong> expose no explicit collaboration mechanisms. Collective
behavior emerges indirectly from shared environment dynamics rather than from intentional
or negotiated coordination among agents.
</p>
</div>
<div class="bg-white border border-gray-300 rounded-lg overflow-hidden">
<table class="w-full text-xs">
<thead class="bg-gray-100">
<tr>
<th class="px-4 py-2 text-left font-semibold text-gray-900 border-b border-gray-300">Framework</th>
<th class="px-4 py-2 text-left font-semibold text-gray-900 border-b border-gray-300">Collaboration</th>
</tr>
</thead>
<tbody class="divide-y divide-gray-200">
<tr>
<td class="px-4 py-2 text-gray-700">Graph-based</td>
<td class="px-4 py-2 text-gray-700">None; procedural only</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">Role-based</td>
<td class="px-4 py-2 text-gray-700">Partial; delegation-based</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">GABM</td>
<td class="px-4 py-2 text-gray-700">None; emergent only</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>
</div>
</section>
<!-- Environment -->
<section id="environment" class="py-20 px-4 sm:px-6 lg:px-8 bg-white border-t border-gray-200">
<div class="max-w-6xl mx-auto">
<h2 class="text-4xl font-bold text-gray-900 mb-8">Environment</h2>
<p class="text-lg text-gray-700 mb-6 leading-relaxed">
This dimension determines whether system execution is mediated through an explicit shared world state
or through agent-local and developer-managed state.
</p>
<div class="grid md:grid-cols-2 gap-8 mb-8">
<div>
<h4 class="text-xl font-semibold text-gray-900 mb-4">How frameworks handle this</h4>
<p class="text-lg text-gray-700 leading-relaxed mb-4">
<strong>Graph-based and role-based frameworks</strong> do not maintain a first-class environment.
They rely instead on workflows and task context effects that are not reflected in a persistent
global state.
</p>
<p class="text-lg text-gray-700 leading-relaxed">
<strong>GABM frameworks</strong> centralize execution around an explicit environment that
tracks world state and applies agent actions over time. This environment maintains grounded
variables that represent the current state of the simulated world.
</p>
</div>
<div class="bg-white border border-gray-300 rounded-lg overflow-hidden">
<table class="w-full text-xs">
<thead class="bg-gray-100">
<tr>
<th class="px-4 py-2 text-left font-semibold text-gray-900 border-b border-gray-300">Framework</th>
<th class="px-4 py-2 text-left font-semibold text-gray-900 border-b border-gray-300">Environment</th>
</tr>
</thead>
<tbody class="divide-y divide-gray-200">
<tr>
<td class="px-4 py-2 text-gray-700">Graph-based</td>
<td class="px-4 py-2 text-gray-700">None; execution context only</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">Role-based</td>
<td class="px-4 py-2 text-gray-700">None; task-centric context</td>
</tr>
<tr>
<td class="px-4 py-2 text-gray-700">GABM</td>
<td class="px-4 py-2 text-gray-700">Explicit world state with grounded variables</td>
</tr>
</tbody>
</table>
</div>
</div>
<p class="text-lg text-gray-700 leading-relaxed">
<strong>Trade-off:</strong> Explicit environments enable persistent state evolution and simulation-based
analysis, but add execution overhead and reduce direct control. Workflow-based execution is more
efficient but lacks persistent global state.
</p>
</div>
</section>
<!-- Synthesis -->
<section class="py-20 px-4 sm:px-6 lg:px-8 bg-gray-50 border-t border-gray-200">
<div class="max-w-6xl mx-auto">
<h2 class="text-4xl font-bold text-gray-900 mb-8">Synthesis: Architectural Trade-offs</h2>
<p class="text-lg text-gray-700 leading-relaxed mb-6">
Across all these dimensions, framework design trades execution control and efficiency for behavioral
flexibility and persistent state modeling.
</p>
<div class="bg-white border border-gray-300 rounded-lg p-8">
<ul class="space-y-4 text-lg text-gray-700">
<li>
<strong>Graph-based architectures</strong> favor deterministic control flow and low-overhead
coordination, supporting predictable and scalable pipelines.
</li>
<li>
<strong>Role-based architectures</strong> relax structural constraints to enable adaptive reasoning
and specialization through declarative roles and task decomposition.
</li>
<li>
<strong>GABM architectures</strong> shift coordination and memory into a shared environment,
supporting emergent behavior and simulation-based analysis at the cost of higher execution
overhead and reduced direct control.
</li>
</ul>
</div>
<p class="text-lg text-gray-700 leading-relaxed mt-6">
Together, these architectures represent distinct trade-offs among predictability, adaptability, and
persistent state coherence in multi-agent systems. Understanding these trade-offs helps you choose
the right framework for your specific needs.
</p>
</div>
</section>
<!-- How Dimensions Interact -->
<section class="py-20 px-4 sm:px-6 lg:px-8 bg-gray-50 border-t border-gray-200">
<div class="max-w-6xl mx-auto">
<h2 class="text-4xl font-bold text-gray-900 mb-8">How These Design Dimensions Interact</h2>
<p class="text-lg text-gray-700 leading-relaxed mb-6">
These dimensions do not operate in isolation. Behavioral specification affects how agents use memory
and tools. Network topology constrains communication patterns, which in turn affects collaboration.
Storage architecture interacts with environment design. The interaction of these dimensions creates
the overall system behavior observed in empirical evaluations.
</p>
<p class="text-lg text-gray-700 leading-relaxed">
Framework paradigms enforce certain combinations of these dimensions while leaving others configurable.
Understanding which dimensions are fixed and which are controllable enables informed framework
selection and system design that matches performance requirements.
</p>
</div>
</section>
<!-- CTA -->
<section class="py-20 px-4 sm:px-6 lg:px-8 bg-white border-t border-gray-200">