A tech tree for agentic patterns — unlock only what your task needs.

• The task requires tool use and the exact path cannot be planned in advance.
• The agent must react adaptively to tool results.
• Adaptivity matters more than minimizing LLM calls.

• The plan is known in advance — use Plan-and-Execute.
• Costs per LLM call are strictly limited.
• The task is pure text generation without external data.

High adaptability is gained at the expense of a significantly higher token and call volume per step.

• The overall goal can be clearly broken down into testable subtasks.
• Execution needs to be traceable and centrally controllable.
• Cost or latency matters; you want to minimize LLM calls.

• The environment is highly dynamic and the plan might fundamentally change based on early tool-call results.
• The task is exploratory and the next step depends on the previous result.

Better structure and testability compared to ReAct, but carries the risk of the agent clinging to outdated or unsuitable plans.

• The required tool calls are identifiable at the beginning.
• LLM calls need to be drastically reduced.

• Tool results branch heavily.
• Interactive error handling per intermediate step is critical.

Significantly lower LLM costs and latency, but at the expense of adaptability during execution.

• Result quality takes precedence over minimal latency.
• Errors can be identified by the model through targeted self-critique.

• The model's self-assessment is unreliable.
• Hard external validations exist.
• Latency and costs are strictly limited.

Leads to higher result quality, but incurs additional token costs and can lead to false confidence.

• The problem has multiple plausible solution paths.
• Early decisions have high cascading effects.
• The search space can be meaningfully evaluated by the LLM.

• The task is linear or directly solvable.
• Costs and latency must remain low.

Enables a much broader and deeper exploration of the solution space, but leads to exponentially increasing computational and token overhead.

• The stochastic diversity of models should be leveraged.
• The result must be robust against individual logic errors in single runs.

• The task can be deterministically validated anyway.
• The cost per request is strictly limited.

Significantly more robust answers against false paths, paid for by multiple inference costs.

• Calculations, data transformations, or complex tool calls must be precisely executable.
• The result should be reproducible.
• Multi-step logic composes more cleanly as one program than as a chain of separate tool calls.

• Code execution cannot be safely isolated in a sandbox.
• The task is purely linguistic.
• The overhead of a code runtime outweighs a single direct tool call.

Maximum precision and reproducibility oppose a high sandbox, security, and runtime overhead.

• The task naturally breaks down into phases, each delivering a verifiable intermediate product.
• Control is more important than autonomy.

• The workflow branches heavily or results dynamically generate new goals.
• Steps can be parallelized without dependencies.

High control-flow predictability is gained at the cost of low flexibility; output content is still non-deterministic at every LLM node.

• Different request classes require distinct handling.
• Specialized tools exist for specific intents.
• Misrouting carries a high cost.

• All tasks use the same flow.
• The classification is unstable.
• The routing logic becomes more complex than the task itself.

More precise handling is achieved at the expense of additional decision logic and the risk of misclassification.

• The input is naturally segmentable and tasks are independent to reduce latency (sectioning).
• Robustness is more important than single execution costs (voting).

• Strong dependencies exist between segments.
• Semantic merging is difficult.
• Latency and token budgets are strictly limited.

Lower latency and higher robustness are gained against increased integration complexity and multiple execution costs.

• The result can be iteratively improved.
• External validation triggers a retry.
• Tool results necessitate new iterations.

• There is no stable exit condition.
• Costs can spiral out of control.
• Errors amplify through repetition.

Adaptive improvement is achieved at the risk of endless or highly expensive execution loops.

• Quality criteria can be explicitly formulated.
• Iterative improvement is measurable.
• Creative outputs need rigorous checking.

• The evaluator cannot provide reliable signals.
• Schema validation suffices.
• The budget does not allow for multiple runs.

Better output quality is gained against additional evaluation complexity and latency.

• Result quality increases gradually and intermediate states must be preserved.
• External feedback is readily available.

• A valid result is typically generated in one step.
• Revisions lack clear signals.
• Consistency drops through repeated rewriting.

Improved artifact quality is achieved at the expense of longer runtimes and potential thematic drift.

• Subtasks only become apparent at runtime.
• Workers handle highly specialized functions.
• Aggregation must remain centrally controlled.

• A static workflow suffices.
• Workers lack clear responsibilities.
• The orchestrator becomes a severe bottleneck.

Highly flexible delegation is gained against significant coordination and integration overhead.

• Large inputs can be split into independent chunks.
• Aggregation logic is clearly definable.
• Throughput scalability is critical.

• Global dependencies exist between chunks.
• The reduction would lose semantic value.
• A central context is required.

Excellent scaling capabilities are achieved against the risk of generating inconsistent partial results.

• Request volume is high with mixed difficulty.
• Cost is a first-order constraint.
• A cheaper model handles a meaningful share of traffic without quality loss.

• Every task needs the top model.
• The complexity rubric is unstable — mis-route cost exceeds the savings.
• The latency of an extra routing hop is unacceptable.

Large cost savings are gained against the effort of tuning and continuously validating the complexity rubric.

• Central control and traceability are essential.
• Multiple specialists must be coordinated.
• Tasks are dynamically delegated.

• Fully decentralized cooperation is needed.
• The supervisor risks becoming a single point of failure.
• Delegation is static enough for simple routing.

Clear operational control is maintained at the cost of a potential coordination bottleneck.

• The number of agents is large.
• Domains must be organized into sub-teams.
• Local decisions need to be aggregated centrally.

• A small number of agents suffices.
• Communication paths must remain short.
• Responsibilities cannot be cleanly separated.

Scalable organizational structure is achieved against higher complexity and longer decision paths.

• Responsibility clearly shifts between specialists.
• User interactions must switch to the appropriate agent.
• Security boundaries apply per agent.

• Multiple agents must contribute simultaneously.
• Control must remain with a central supervisor.
• Context transfer cannot be reliably bounded.

Clear transfer of responsibility is achieved at the risk of losing vital context during the handoff.

• Decentralized exploration is desired.
• Tasks can be adaptively distributed.
• Central control would be too rigid.

• Strict traceability is required.
• Message floods must be prevented.
• Clear accountability outweighs emergent behavior.

High adaptability is gained at the cost of lower predictability and difficult debugging.

• Perspectives must be visibly merged.
• Discussion is part of the solution process.
• Roles need to interact flexibly.

• A deterministic flow is required.
• The token budget is heavily restricted.
• Responsibilities must remain strictly isolated.

Rich interaction is gained against high token costs and difficult flow control.

• The problem allows for controversial assessments.
• Counterarguments help expose logical flaws.
• Decisions require rigorous verification.

• Facts are easily verifiable.
• Debate would create artificial conflicts.
• Latency budgets are tight.

Rigorous verification of difficult decisions is achieved against increased effort and the risk of over-arguing.

• Tasks are open-ended, multi-step, and tool-intensive.
• Multiple specialists must operate with high autonomy over long horizons.

• A simple workflow suffices.
• Auditability requires deterministic steps.
• Operating costs are strictly limited.

Massive task coverage is gained against exceptionally high operational and orchestration complexity.

• Many agents contribute asynchronously.
• Shared state is more important than direct conversation.
• Intermediate results must remain persistent.

• Strict linear control is required.
• State consistency cannot be guaranteed.
• A simple chat context suffices.

Highly decoupled collaboration is achieved against demanding state management and consistency requirements.

• Tasks must be distributed dynamically.
• Agents possess varying capacities or costs.
• Prioritization relies on utility signals.

• Delegation is fixed.
• Bidding creates more overhead than value.
• Compliance dictates strict rule-based allocation.

Scalable and flexible resource allocation is gained against the difficult design of incentive and auction structures.

• Specialists must be encapsulated.
• The main agent must retain absolute control.
• Security boundaries must be strictly separated.

• Equal cooperation is needed.
• Specialists require long-term autonomy.
• Interface contracts are unstable.

Excellent encapsulation is achieved against limited independence for the sub-agents.

• Coordination must be completely traceable and testable.
• Complex flows involving cycles and strict conditions must run stably in production.

• A linear workflow is sufficient.
• Graph maintenance outweighs the benefits.
• Autonomous emergence is preferred over explicit control.

Extreme predictability and controllability are gained against significant modeling overhead.

• The task is open-ended research, competitive analysis, or literature / R&D synthesis across many sources.
• Breadth and novelty matter more than a single lookup.
• Findings must be synthesized and cited, not just retrieved.

• The answer is a bounded lookup or a single retrieval.
• Cost and latency budgets are tight — this pattern is resource-intensive.
• The knowledge space is small enough for one pass.

Breadth, novelty, and synthesis quality are gained at a high token and latency cost; it needs strong stopping criteria to avoid unbounded exploration.