ArchGen

Multi-Agent LLM Swarm Architecture

Focus: Orchestrator + Researcher/Coder/Critic + Shared Memory + Vector DB Retention. Key areas: Web App, REST/gRPC API, WebSocket (optional).

Use this as a block diagram of the system when explaining architecture.

Preview
Edit this example
Diagram caption: Multi-Agent LLM Swarm Architecture (Orchestrator + Researcher/Coder/Critic + Shared Memory + Vector DB Retention) has 5 layers: User & Interaction Layer, Agent Orchestration Layer, Specialized Worker Agents (Swarm), Shared Memory & Long-Term Knowledge Layer, Observability & Operations Layer.

Prompt

Multi-Agent LLM system architecture involving a collaborative swarm of agents. Center the design around an Orchestrator Agent that decomposes user tasks. Connect it to specialized worker agents: a Researcher Agent (with web search tools), a Coder Agent (with Python interpreter), and a Critic Agent (for review). All agents should read/write to a Shared Memory module and a Vector Database for long-term knowledge retention.
Highlights
  • Layer details · User & Interaction Layer: Modules include User Interface (Chat/API).
  • Layer details · Agent Orchestration Layer: Modules include Orchestrator Agent (Planner/Router), Workflow Coordinator (Execution Engine), Policy & Guardrails.
  • Module responsibilities · User & Interaction Layer / User Interface (Chat/API): Collect user intent and constraints; Deliver final outputs and intermediate results; Support iterative refinement

Overview

Multi-Agent LLM Swarm Architecture (Orchestrator + Researcher/Coder/Critic + Shared Memory + Vector DB Retention) has 5 layers: User & Interaction Layer, Agent Orchestration Layer, Specialized Worker Agents (Swarm), Shared Memory & Long-Term Knowledge Layer, Observability & Operations Layer.

Layer details

Show all (5)
  • User & Interaction Layer: Modules include User Interface (Chat/API).
  • Agent Orchestration Layer: Modules include Orchestrator Agent (Planner/Router), Workflow Coordinator (Execution Engine), Policy & Guardrails.
  • Specialized Worker Agents (Swarm): Modules include Researcher Agent (Web Search), Coder Agent (Python Interpreter), Critic Agent (Review & QA).
  • Shared Memory & Long-Term Knowledge Layer: Modules include Shared Memory (Blackboard / Scratchpad), Vector Database (Long-Term Retention), Memory Write/Read API.
  • Observability & Operations Layer: Modules include Tracing, Metrics, and Logs, Model Gateway (Optional).

Module responsibilities

Show all (12)
  • User & Interaction Layer / User Interface (Chat/API): Collect user intent and constraints; Deliver final outputs and intermediate results; Support iterative refinement
  • Agent Orchestration Layer / Orchestrator Agent (Planner/Router): Translate user intent into an executable plan; Assign subtasks to specialized agents; Aggregate results into a coherent final response
  • Agent Orchestration Layer / Workflow Coordinator (Execution Engine): Run agent steps reliably and deterministically; Enforce compute/token budgets per task; Handle partial failures and re-planning
  • Agent Orchestration Layer / Policy & Guardrails: Prevent unsafe or unauthorized tool usage; Enforce data access boundaries; Validate outputs for policy compliance
  • Specialized Worker Agents (Swarm) / Researcher Agent (Web Search): Gather up-to-date external information; Provide grounded summaries with sources; Feed evidence back to orchestrator
  • Specialized Worker Agents (Swarm) / Coder Agent (Python Interpreter): Implement and validate solutions with executable code; Run calculations and produce artifacts; Return tested snippets and results
  • Specialized Worker Agents (Swarm) / Critic Agent (Review & QA): Audit intermediate/final outputs for correctness; Identify gaps, edge cases, and failure modes; Recommend improvements and request rework
  • Shared Memory & Long-Term Knowledge Layer / Shared Memory (Blackboard / Scratchpad): Provide a single source of truth during execution; Enable collaboration and handoffs across agents; Support resumability for multi-step tasks
  • Shared Memory & Long-Term Knowledge Layer / Vector Database (Long-Term Retention): Store long-term knowledge for future retrieval; Enable semantic recall across conversations/tasks; Support RAG-style memory augmentation
  • Shared Memory & Long-Term Knowledge Layer / Memory Write/Read API: Standardize how agents persist and recall memory; Prevent leaking sensitive data into shared stores; Provide deterministic retrieval for workflows
  • Observability & Operations Layer / Tracing, Metrics, and Logs: Monitor system performance and reliability; Provide audit trails for tool usage; Enable debugging across multi-agent runs
  • Observability & Operations Layer / Model Gateway (Optional): Centralize LLM access across agents; Control cost and availability via routing; Provide consistent prompting and versioning

Key flows

Show all (3)
  • Task execution: the Orchestrator Agent decomposes the user request into subtasks, writes the plan into Shared Memory, and dispatches work to the Researcher/Coder/Critic agents in parallel where possible, collecting their outputs back into Shared Memory.
  • Tool-assisted collaboration: the Researcher Agent uses web search tools to gather citations and evidence, the Coder Agent uses a Python interpreter to compute/validate results or generate artifacts, and the Critic Agent reviews outputs for correctness, safety, and completeness before the Orchestrator synthesizes the fi
  • Long-term retention: as milestones are reached, agents summarize key findings and write them to Shared Memory and the Vector Database (embedded with metadata); future tasks retrieve top-k relevant memories from the Vector DB to ground planning and reduce repeated work.