Technical Components: Cross-Paradigm Reference

Overview

This document provides a systematic comparison of how each of the five core technical components is implemented across the four agentic paradigms. This analysis reveals the architectural patterns that determine an agent's capabilities and limitations.

---

Component 1: Strategic Planning

Strategic planning bridges high-level objectives with executable actions through decomposition (structuring the problem) and iteration (refining the approach).

Decomposition Strategies

Paradigm	Goal	Pattern	Key Techniques
LSC	Architect internal cognition	Internal reasoning chains	Chain-of-thought, Causal alignment, Multi-perspective decomposition
GS	Construct logical inquiry paths	External source mapping	Query dependency graphs, Sub-query generation, Schema-driven decomposition
EP	Enable cognitive self-guidance	Cognitive map construction	Self-consistency, Tree-planner, Implicit cognitive frameworks
VWA	Map to protocol nodes	Verified workflow alignment	PICO structuring, Graph-of-thought, Safety boundary enforcement

Decomposition Architecture Comparison

LSC: Query → [CoT Reasoning] → [Multi-Perspective Split] → Internal Hypothesis Tree
     └── Operates entirely within parametric memory

GS:  Query → [Sub-Query Generation] → [Query Dependency Graph] → External Source Routing
     └── Maps to specific external verification sources

EP:  Query → [Cognitive Map] → [Probabilistic Action Space] → Autonomous Plan Generation
     └── Creates executable workflow from implicit knowledge

VWA: Query → [PICO Structuring] → [Protocol Node Mapping] → Verified Step Selection
     └── Constrains to pre-defined clinical pathways

Iteration Strategies

Paradigm	Goal	Pattern	Key Techniques
LSC	Ensure consistency	Deliberative cycles	Multi-round reasoning, Counterfactual validation, Analogical reasoning
GS	Gap-filling	Information-query loops	Cyclical schema completion, Evidence hierarchy resolution, Progressive deepening
EP	Dynamic adjustment	Self-reflection	Reflexion framework, Dialogue-driven feedback, Plan critique
VWA	Adaptive navigation	Closed-loop correction	Locate-and-correct, RL path optimization, Hierarchical cyclic execution

Iteration Flow Comparison

LSC: Hypothesis → [Consistency Check] → [Adjust] → Refined Hypothesis
     └── Internal validation without external data

GS:  Retrieved Evidence → [Schema Gap Analysis] → [Targeted Re-Query] → Complete Profile
     └── External data drives iteration

EP:  Executed Step → [Self-Reflection] → [Critique] → Plan Modification
     └── Action outcomes drive refinement

VWA: Workflow Position → [Feedback Analysis] → [Policy Update] → Optimized Path
     └── Protocol compliance drives iteration

---

Component 2: Memory Management

Memory enables agents to maintain state and leverage knowledge. The fundamental distinction is between parametric (model weights) and non-parametric (external context) memory.

Parametric Memory Functions

Paradigm	Primary Role	Key Characteristics
LSC	Internalized medical curriculum	Source of clinical truth; activated via prompting
GS	Semantic translator	Cognitive processor; NOT source of facts
EP	Strategic engine	Encodes procedural knowledge; workflow intuition
VWA	Instruction parser	Semantic processor; bridges NL to tool calls

Parametric Memory Architecture

                    LSC                    GS                    EP                    VWA
                    │                      │                     │                     │
Function:     Knowledge Source       Query Generator      Strategic Engine      Intent Translator
                    │                      │                     │                     │
Trust Level:  Primary truth          Auxiliary only       Workflow guide        Navigation tool
                    │                      │                     │                     │
Update:       Fine-tuning            Limited updates      Pattern refinement    Tool mapping

Non-Parametric Memory Functions

Paradigm	Primary Role	Key Characteristics
LSC	Patient context window	Maintains dialogue continuity; prevents forgetting
GS	Evidential ledger	Auditable trace; firewalled from parameters
EP	Tactical workspace	Dynamic workflow log; action trajectory
VWA	State register	Clinical axioms + session state; verifiable log

Non-Parametric Memory Architecture

LSC: Context Window
     ├── Recursive Summarization (memory proxy)
     ├── Long-Context Models (extended capacity)
     └── Status Tracking (symptom evolution)

GS:  Evidence Ledger
     ├── Source Attribution (audit trail)
     ├── Information Compartmentalization (firewall)
     └── Conflict Detection (reliability checks)

EP:  Workflow Log
     ├── Dynamic Action History
     ├── Status Highlights
     └── External Interface Tracking

VWA: State Register
     ├── Static Memory (clinical axioms, EHR graphs)
     ├── Dynamic Memory (entity maps, action records)
     └── Validation Checkpoints

Memory Management Critical Patterns

Pattern	LSC	GS	EP	VWA
Knowledge contamination prevention	N/A (trusts parameters)	Critical (firewall required)	N/A (trusts parameters)	Critical (compartmentalization)
Catastrophic forgetting	Major concern	Minor (external sources)	Major concern	Minor (external sources)
Context window limits	Primary challenge	Secondary	Primary challenge	Secondary
State persistence	Session-based	Transaction-based	Workflow-based	Protocol-based

---

Component 3: Action Execution

Action execution connects planning to the external world. Note: This component is primarily relevant for explicit knowledge paradigms (GS and VWA).

Action Modalities

Modality	Purpose	GS Implementation	VWA Implementation
Knowledge-Based	Structured queries	KG traversal, semantic queries	EHR vector DB, diagnostic KG
Search Engine	Unstructured retrieval	Forage-Constrain-Attribute	Query optimization + validation
Tool-Use	Deterministic computation	Calculators, risk scores	SQL generation, expert systems

Knowledge-Based Action Patterns

GS Knowledge Actions:
┌─────────────────────────────────────────┐
│  Query → KG Traversal → Logical Proof   │
│      └── Axiomatic skeleton             │
│      └── Audit trail per transaction    │
│      └── Schema-enforced constraints    │
└─────────────────────────────────────────┘

VWA Knowledge Actions:
┌─────────────────────────────────────────┐
│  Query → Vector Retrieval → Validation  │
│      └── Hierarchical chunking          │
│      └── EHR graph+ (weighted edges)    │
│      └── Evidence triplet linking       │
└─────────────────────────────────────────┘

Search Engine Action Workflow

GS Three-Stage Process:

1. Forage: Strategic multi-round query sequence for comprehensive corpus
2. Constrain: Firewall snippets in isolated context (strict grounding)
3. Attribute: Mandate fine-grained citation pointers for every claim

VWA Three-Stage Process:

1. Optimize: Context-aware query generation (MeSH mapping)
2. Route: Dispatch to specialized domain indices
3. Validate: Entropy-based assessment of snippet contribution

Tool-Use Action Patterns

Aspect	GS Approach	VWA Approach
Philosophy	Cognitive liability offloading	Clinical orchestration
Tool Types	Calculators, risk scores, simulators	SQL, calculators, expert systems
LLM Role	Semantic interface	Intelligent orchestrator
Authority	Tool inherits credibility	Protocol inherits credibility

Action Execution Summary

                      GS                                    VWA
                      │                                     │
Goal:           Evidence Acquisition              Workflow Progression
                      │                                     │
Pattern:        Retrieve → Verify → Cite          Execute → Validate → Log
                      │                                     │
Outcome:        Grounded Snapshot                 Protocol Completion

---

Component 4: Collaboration

Collaboration defines how agents work together or with humans. The topology significantly impacts system behavior.

Single-Agent Architectures

Paradigm	Analogy	Strengths	Weaknesses
LSC	General practitioner	Efficient, coherent	Cognitive tunneling
GS	Information specialist	Direct control	Scalability limits
EP	Autonomous practitioner	End-to-end capability	Limited specialization
VWA	Protocol executor	Clear accountability	Single point of failure

Multi-Agent Topologies

Dominant (Hierarchical) Topology:

                    ┌───────────────────┐
                    │  Orchestrator     │
                    │  Agent            │
                    └─────────┬─────────┘
              ┌───────────────┼───────────────┐
              │               │               │
        ┌─────┴─────┐   ┌─────┴─────┐   ┌─────┴─────┐
        │ Specialist │   │ Specialist │   │ Specialist │
        │ Agent A    │   │ Agent B    │   │ Agent C    │
        └───────────┘   └───────────┘   └───────────┘

Distributed (Peer-to-Peer) Topology:

        ┌───────────────┐       ┌───────────────┐
        │   Agent A     │◄─────►│   Agent B     │
        └───────┬───────┘       └───────┬───────┘
                │                       │
                │    ┌─────────────┐    │
                └───►│ Common Goal │◄───┘
                     └──────┬──────┘
                            │
                     ┌──────┴──────┐
                     │   Agent C   │
                     └─────────────┘

Topology Usage by Paradigm

Paradigm	Dominant Topology Role	Distributed Topology Role
LSC	Clinical ward (chief physician)	Case conference (peer debate)
GS	Evidence aggregation hub	Data flow pipeline (DAG)
EP	Meta-planning coordinator	Conflict resolution via negotiation
VWA	Attending physician model	Care pathway handoffs

Collaboration Patterns

Pattern	Implementation	Paradigms
Consultation Simulation	Expert roles debate within latent space	LSC
Evidence Aggregation	Central hub compiles multi-source evidence	GS
Task Negotiation	Agents broadcast intentions, resolve conflicts	EP
Protocol Handoff	Strict sequential transfer between stages	VWA

---

Component 5: Evolution

Evolution enables agents to improve over time. The approach varies significantly based on knowledge source.

Evolution Mechanisms by Paradigm

Paradigm	Primary Mechanism	Goal
LSC	Continual learning	Prevent forgetting; integrate new knowledge
GS	Strategy refinement	Optimize inquiry efficiency
EP	Meta-learning	Abstract generalizable heuristics
VWA	Workflow tuning	Refine tool-use and protocol execution

Evolution Architecture

LSC Evolution:
├── Regularization (preserve established knowledge)
├── Experience Replay (reinforce successful diagnoses)
└── Model Expansion (allocate capacity for new domains)

GS Evolution:
├── Inquiry Pathway Optimization (efficiency metrics)
├── Action Policy Refinement (tool adaptation)
└── Human-in-Loop Knowledge Expansion (demand-driven updates)

EP Evolution:
├── Outcome-Driven RL (reinforce successful action sequences)
├── Meta-Heuristic Abstraction (pattern extraction)
└── Proactive Self-Repair (capability gap detection)

VWA Evolution:
├── Workflow Component Refinement (evolutionary algorithms)
├── Behavioral Adaptation (collaborative strategy learning)
└── Meta-Tool Learning (interaction pattern optimization)

Evolution Comparison Matrix

Aspect	LSC	GS	EP	VWA
What evolves	Model parameters	Query strategies	Action policies	Tool-use patterns
Feedback source	Training loss	Cognitive efficiency	Clinical outcomes	Protocol compliance
Risk	Catastrophic forgetting	Strategy drift	Policy instability	Overfitting to specific tools
Human role	Retraining	Knowledge curation	Outcome labeling	Workflow maintenance
Speed	Slow (retraining)	Fast (strategy)	Medium (RL)	Fast (tuning)

---

Cross-Component Integration Patterns

How Components Interact

┌─────────────────────────────────────────────────────────────────────┐
│                    AGENTIC SYSTEM ARCHITECTURE                      │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ┌───────────────┐    ┌───────────────┐    ┌───────────────┐       │
│  │   PLANNING    │───►│    MEMORY     │───►│    ACTION     │       │
│  │ Decomposition │    │  Parametric   │    │  Knowledge    │       │
│  │ Iteration     │    │  Non-Param.   │    │  Search       │       │
│  └───────┬───────┘    └───────┬───────┘    │  Tool-Use     │       │
│          │                    │            └───────┬───────┘       │
│          │                    │                    │               │
│          │    ┌───────────────┴───────────────┐    │               │
│          │    │                               │    │               │
│          ▼    ▼                               ▼    ▼               │
│  ┌─────────────────────────────────────────────────────────┐       │
│  │                   COLLABORATION                         │       │
│  │            Single-Agent / Multi-Agent                   │       │
│  │        Dominant Topology / Distributed Topology         │       │
│  └───────────────────────────┬─────────────────────────────┘       │
│                              │                                     │
│                              ▼                                     │
│  ┌─────────────────────────────────────────────────────────┐       │
│  │                     EVOLUTION                           │       │
│  │    Continual Learning / Strategy Refinement / RL        │       │
│  └─────────────────────────────────────────────────────────┘       │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Integration Patterns by Paradigm

LSC Integration: Planning drives Memory activation → Collaboration refines → Evolution updates parameters

GS Integration: Planning generates queries → Action retrieves → Memory stores → Collaboration aggregates

EP Integration: Planning creates workflow → Memory logs → Collaboration executes → Evolution refines policy

VWA Integration: Planning maps protocol → Memory tracks state → Action executes → Collaboration hands off

---

Design Decision Framework

When to Emphasize Each Component

Scenario	Critical Component	Secondary Components
Complex reasoning	Planning (deep decomposition)	Memory (context)
Long conversations	Memory (non-parametric)	Planning (iteration)
External data integration	Action (knowledge-based)	Memory (ledger)
Team-based decisions	Collaboration (multi-agent)	Evolution (strategy)
Continuous improvement	Evolution	All others

Trade-offs in Component Design

Strong Component	Benefit	Cost
Planning	Better goal achievement	Computational overhead
Memory	Better context handling	Storage/retrieval latency
Action	Better grounding	External dependency
Collaboration	Better robustness	Coordination complexity
Evolution	Better adaptation	Training investment