Use memory
Choose memory only when task continuity is worth the state burden
If the agent must return to work, preserve context or maintain long threads, memory is justified. Otherwise pipelines stay simpler.
Agent stacks
Choose the agent stack that matches the work, not the one with the loudest demo.
This board separates pipelines, retrieval stacks, memory-enabled agents, multi-agent orchestrators, coding agents, browser automation and local-first stacks before implementation begins.
Families compared
7
Stack archetypes
High-control lanes
6
Deterministic or tightly governed
Memory-aware lanes
6
State or persistence matters
High-complexity lanes
4
Multi-agent or browser-heavy
Use multi-agent
Choose multi-agent only when roles are truly separable
If you cannot define ownership, handoffs and validation, a single stateful agent is usually the better design.
Use browser stacks
Choose browser or computer-use only when the interface is the source of truth
If an API exists and is sufficient, browser automation should usually stay out of the critical path.
Compare agent stack families by operating reality
| Stack family | Use when | Control and memory | Budget and complexity | Caution |
|---|---|---|---|---|
| Simple pipelines Temporal, n8n, Queues + workers | Use it when the real problem is coordinating reliable tasks, not simulating autonomy Repeatable flows, approvals, operational ETL and automation with clear steps | High and deterministic No conversational memory required | Low-medium Predictable | If you force too much autonomy into a fixed pipeline, support gets harder with little upside Official source: Temporal docs |
| Retrieval + tools stacks LlamaIndex, PydanticAI, LangGraph | Use it when you need tools and retrieval before you need a swarm of agents Grounded copilots, internal assistants and workflows that rely on your own data | High if you define retrieval, tools and guardrails Light or contextual memory | Medium Mid and controllable | Quality falls quickly if retrieval, ranking and tool policy are not defined well Official source: LlamaIndex docs |
| Stateful single agents LangGraph, PydanticAI, Custom memory store | Use it when one memory-enabled agent is enough and multi-agent would be over-engineering Agents that revisit work, remember context and need task continuity | High with a solid state layer Persistent or session memory | Medium-high Variable | Memory without a clear policy creates context bloat and inconsistent decisions Official source: LangGraph docs |
| Multi-agent orchestrators CrewAI, AutoGen, LangGraph supervisor | Use it when one loop is not enough and you can define ownership, handoffs and validation Complex problems with distinct roles, real parallelism and coordination needs | Medium-high, depends on ownership and messaging Shared or per-agent memory | High High without strict routing | Without file ownership, traceability and autonomy limits, cost and complexity explode Official source: CrewAI docs |
| Coding agents Codex CLI, Claude Code, Repo tool runners | Use it when the center of gravity is the repository, not a conversational UI Bounded refactors, test generation, code review and tool-guided execution | High if the repo has checks and ownership Repo and task context | Medium Mid-high depending on model | Without build, tests and small diffs, throughput turns into technical debt Official source: PydanticAI docs |
| Browser and computer-use stacks Playwright, Browser tool runners, Computer-use loops | Use it when the only source of truth is the interface and no sufficient API exists Web ops, QA, forms, guided scraping and tasks where the UI is part of the work | Medium unless you add asserts and snapshots Short memory and browser state | High Mid-high because of operational fragility | This family is most sensitive to UI changes, auth and non-deterministic flows Official source: Playwright docs |
| Local-first agent stacks Ollama, Local tool runners, Private vector stores | Use it when data residence, recurring cost or local autonomy matter more than the latest benchmark Privacy, sovereignty, edge and teams willing to trade some frontier quality for control | Very high Memory and data under local control | Medium-high Capex first, low opex | Hardware, observability and model maintenance become part of the product Official source: Ollama docs |
Simple pipelines
Temporal, n8n, Queues + workers
Use when: Use it when the real problem is coordinating reliable tasks, not simulating autonomy
Best for: Repeatable flows, approvals, operational ETL and automation with clear steps
Control: High and deterministic
Memory: No conversational memory required
Complexity: Low-medium
Budget: Predictable
Caution: If you force too much autonomy into a fixed pipeline, support gets harder with little upside
Official sourceRetrieval + tools stacks
LlamaIndex, PydanticAI, LangGraph
Use when: Use it when you need tools and retrieval before you need a swarm of agents
Best for: Grounded copilots, internal assistants and workflows that rely on your own data
Control: High if you define retrieval, tools and guardrails
Memory: Light or contextual memory
Complexity: Medium
Budget: Mid and controllable
Caution: Quality falls quickly if retrieval, ranking and tool policy are not defined well
Official sourceStateful single agents
LangGraph, PydanticAI, Custom memory store
Use when: Use it when one memory-enabled agent is enough and multi-agent would be over-engineering
Best for: Agents that revisit work, remember context and need task continuity
Control: High with a solid state layer
Memory: Persistent or session memory
Complexity: Medium-high
Budget: Variable
Caution: Memory without a clear policy creates context bloat and inconsistent decisions
Official sourceMulti-agent orchestrators
CrewAI, AutoGen, LangGraph supervisor
Use when: Use it when one loop is not enough and you can define ownership, handoffs and validation
Best for: Complex problems with distinct roles, real parallelism and coordination needs
Control: Medium-high, depends on ownership and messaging
Memory: Shared or per-agent memory
Complexity: High
Budget: High without strict routing
Caution: Without file ownership, traceability and autonomy limits, cost and complexity explode
Official sourceCoding agents
Codex CLI, Claude Code, Repo tool runners
Use when: Use it when the center of gravity is the repository, not a conversational UI
Best for: Bounded refactors, test generation, code review and tool-guided execution
Control: High if the repo has checks and ownership
Memory: Repo and task context
Complexity: Medium
Budget: Mid-high depending on model
Caution: Without build, tests and small diffs, throughput turns into technical debt
Official sourceBrowser and computer-use stacks
Playwright, Browser tool runners, Computer-use loops
Use when: Use it when the only source of truth is the interface and no sufficient API exists
Best for: Web ops, QA, forms, guided scraping and tasks where the UI is part of the work
Control: Medium unless you add asserts and snapshots
Memory: Short memory and browser state
Complexity: High
Budget: Mid-high because of operational fragility
Caution: This family is most sensitive to UI changes, auth and non-deterministic flows
Official sourceLocal-first agent stacks
Ollama, Local tool runners, Private vector stores
Use when: Use it when data residence, recurring cost or local autonomy matter more than the latest benchmark
Best for: Privacy, sovereignty, edge and teams willing to trade some frontier quality for control
Control: Very high
Memory: Memory and data under local control
Complexity: Medium-high
Budget: Capex first, low opex
Caution: Hardware, observability and model maintenance become part of the product
Official sourceRoute
LLM route
Return to the routing layer if the blocker is still vendor, row-level model detail or workflow scope.
Route
Model fit radar
Use scenario-first model picks when the stack family is clear but the default model lane is not.
Route
Inference guide
Jump to hardware guidance when private serving, VRAM or workstation shape now limits the stack.
Route
Workflow recipes
Use practical operating recipes when the family is chosen and the next question is how to run it.
Route
Agent directory
Return to the framework map once the stack family is decided and you need vendor tooling context.