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.
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.
Graph-based frameworks 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.
Role-based frameworks 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.
GABM frameworks treat roles, goals, and plans as optional. Behavior emerges from agents repeatedly observing the environment and taking actions, rather than following explicit instructions.
| Feature | Graph | Role | GABM |
|---|---|---|---|
| Role | Implicit | Explicit | Optional |
| Goal | Graph-determined | First-class object | Environment-driven |
| Planning | Embedded in graph | Pre-task or manager-worker | Optional |
Trade-off: 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.
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.
Graph-based frameworks 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.
Role-based frameworks 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.
GABM frameworks 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.
| Memory Type | Graph | Role | GABM |
|---|---|---|---|
| LTM | ✓ Retrieval-based | ✓ Retrieval-based | ✓ LLM-queried |
| STM | ✓ Conversation/state | ✓ RAG-based context | ✗ Not native |
| EM | ✗ Manual | ✓ Optional structured | ✗ Not native |
| WM | ✗ Developer-managed | ✗ Implicit | ✓ Derived from LTM |
| EK | ✗ Not native | ✓ Attachable | ✗ Not native |
Trade-off: 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.
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.
Graph-based frameworks 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.
Role-based frameworks bind tools to agent roles and task context. Agents can dynamically select tools during reasoning, but access is constrained by orchestration semantics.
GABM frameworks remove direct tool access from agents. All external actions route through an environment controller that interprets agent intentions and updates global state.
| Framework | Tool Model |
|---|---|
| Graph-based | Agent-bound or graph nodes |
| Role-based | Agent-bound, role-constrained |
| GABM | Environment-executed |
Trade-off: 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.