Developers · Architecture
Agentic Application Architecture and Design Patterns
Production agent architectures — ReAct, planner-executor, reflection and multi-agent — all need a memory layer for state, learning and consistency across steps.
Agent patterns
ReAct
ReAct and tool loops
Reason → Act → Observe loops with tool calls — memory stores conversation state and extracted facts between iterations.
Memory sits as both conversation buffer (short-term) and fact store (long-term). Include memory tools (search_memory, write_memory) in the tool set so the agent persists learnings across ReAct steps.
Planner
Planner-executor
Planner writes plan to shared memory; executor reads and updates task state.
Shared memory store coordinates planner and executor agents. Namespace by task_id; executor writes progress back for planner to revise. See shared memory and multi-agent memory guide.
Reflection
Reflection and self-improvement
Store critiques and lessons learned — procedural and episodic memory for agent self-improvement.
After task completion, reflection agent writes “what worked / what failed” to procedural memory. Future runs retrieve these lessons before planning. Park et al. (2023) importance scoring helps rank reflection memories.
Multi-agent
Multi-agent architectures
Coordinator + workers with shared store — blackboard or event-sourced memory projection.
Engram scoped collections, Zep org-level graph, LangGraph shared store or Redis pub/sub for real-time sync. Conflict resolution via versioning or temporal invalidation.
Summary
Memory in each pattern
| Pattern | Memory type | Framework hints |
|---|---|---|
| ReAct | STM buffer + LTM facts | Engram, Mem0, LangMem |
| Planner-executor | Shared task state | LangGraph store, Redis |
| Reflection | Procedural lessons | Engram, Mem0 |
| Multi-agent | Shared collective store | Engram, Zep, LangGraph |
| Long-context paging | Core + archival tiers | Letta (MemGPT) |
FAQ
Frequently asked questions
Best agentic pattern to start with?
ReAct with memory tools for most teams — simple loop, easy to debug. Graduate to planner-executor or multi-agent when task complexity demands it.
What memory does each agent pattern need?
ReAct: STM buffer + LTM facts. Planner-executor: shared task state. Reflection: procedural lessons. Multi-agent: collective shared store. See pattern table on this page.
LangGraph agentic patterns?
LangGraph supports ReAct, planner-executor and multi-agent via graph nodes. Pair with LangMem or Engram/Mem0 for LTM.
Letta agent architecture?
MemGPT paging — core memory in-context, archival paged on demand. DMR 93.4% (Packer et al., 2023). See Letta alternatives.
Memory in multi-agent architectures?
Shared store with namespace scoping, conflict policies and coordinator patterns. See multi-agent memory.
Production reference architecture for agents?
Model + orchestration (LangGraph/Letta) + memory layer (Engram/Mem0/Zep) + eval (LOCOMO in CI) + observability. See memory layer.