Chapter 7: Agentic Design Patterns

1. Reactive Pattern

Prioritizes latency, determinism, and throughput with minimal planning.

pattern: reactive
routing:
  - match: "reset password"
    tool: identity.reset_password
    requires_confirmation: true
  - match: "invoice status"
    tool: billing.lookup_invoice
  - match: "shipping"
    tool: logistics.track_package
fallback:
  mode: deliberative
telemetry:
  log:
    - route
    - tool_name
    - tool_status
    - latency_ms

Best For: High-volume transactional workflows (status lookup, credential reset, invoice retrieval)

Failure Modes: Silent tool misuse, overconfident actions under ambiguity

2. Deliberative Pattern

Constructs explicit execution plans prior to tool invocation with structured validation.

pattern: deliberative
plan_schema:
  steps:
    - id: string
      intent: string
      tool: string
      success_criteria: string
      rollback: string
constraints:
  max_steps: 10
  cost_budget_usd: 0.75
execution:
  step_mode: sequential
  replan_on:
    - tool_error
    - contradiction
    - low_confidence

Best For: Multi-step workflows with dependencies, cost management, risk control

3. Goal-Seeking Pattern

Maintains target system state and iteratively minimizes divergence.

pattern: goal_seeking
goal_state:
  definition: "Complete onboarding packet"
progress_signals:
  - checklist_items_completed
  - missing_artifacts_count
stop_conditions:
  - checklist_items_completed == 1.0
  - attempts >= 3 -> escalate_to_human

Best For: State convergence tasks with measurable progress signals

4. Self-Reflective Pattern

Evaluates own outputs through structured critique loops before final response.

pattern: self_reflective
max_reflection_rounds: 2
rubric:
  axes:
    - factuality
    - completeness
    - policy
    - style
stop_if:
  - score >= 0.92
  - delta_improvement < 0.02

Best For: High-quality content generation requiring refinement

5. Reasoning Without Observation (RwO)

Internal planning and hypothesis generation followed by external verification.

pattern: rwo_then_verify
phase_1:
  mode: reasoning_without_observation
  output: candidate_plan
phase_2:
  mode: verify_with_tools
  checks:
    - retrieve_policy_docs
    - validate_tool_permissions
    - confirm_user_intent
phase_3:
  mode: execute_deliberatively

Best For: Complex planning requiring validation before execution

1. ReAct Execution Loop

Interleaves reasoning, tool invocation, and observation in iterative control loop.

pattern: react
loop:
  while task_not_complete:
    step_1: reason
    step_2: call_tool
    step_3: observe_output
    step_4: update_state
termination:
  - goal_state_reached
  - budget_exhausted
  - escalation_triggered

Benefits: Grounds reasoning through real-world feedback, reduces hallucination

Risks: Unbounded loops without governance, oscillating reasoning branches

2. Reflect-Replan-Retry Pattern

Structured recovery when execution failures occur with failure classification.

pattern: reflect_replan_retry
on_tool_failure:
  classify_failure:
    - transient
    - deterministic
    - policy_violation
  reflect:
    analyze_failure_context
  replan:
    modify_tool_parameters
    OR
    select_alternative_tool
  retry:
    bounded_attempts: 2
  escalate:
    if failure_persists

Benefits: Differentiates transient vs deterministic failures, reduces cascading errors

3. Tool Feedback Recovery Pattern

Cross-validates results across redundant or complementary tool sources.

pattern: tool_feedback_recovery
primary_tool_call:
  result_A
secondary_validation:
  result_B
consistency_check:
  if mismatch:
    invoke_third_source
resolution_strategy:
  majority_vote
  OR
  weighted_confidence

Best For: High-stakes workflows (compliance auditing, financial reconciliation)

4. Execution Budget Governance

Enforces cost, latency, and safety boundaries across ARC+ loops.

budget_control:
  max_tool_calls: 15
  max_execution_time_sec: 60
  max_token_budget: 15000
on_budget_violation:
  trigger_escalation
  OR
  degrade_response_mode

Benefits: Prevents pathological execution cycles, controls costs

1. Tree-of-Thought Reasoning

Expands single reasoning chain into multiple candidate branches.

pattern: tree_of_thought
root_problem:
  generate_initial_branches: 3
branch_evaluation:
  scoring_criteria:
    - logical_consistency
    - goal_alignment
    - evidence_support
pruning:
  retain_top_k: 2
termination:
  - solution_confidence >= threshold
  - branch_budget_exhausted

Best For: Planning, mathematical reasoning, policy synthesis, multi-step design

2. Graph-of-Thought Reasoning

Allows reasoning nodes to share intermediate results across solution paths.

pattern: graph_of_thought
nodes:
  - claim
  - evidence
  - inference
edges:
  represent_dependency
reuse:
  shared_subgraphs_enabled: true
validation:
  detect_contradictions

Benefits: Reduces redundant computation, improves traceability

3. Monte Carlo Search Reasoning

Probabilistic rollout strategies to evaluate action sequences.

pattern: monte_carlo_reasoning
rollout:
  simulate_action_sequences
value_estimation:
  score_expected_outcomes
selection:
  choose_highest_expected_value
iteration_limit:
  max_rollouts: 20

Best For: Optimization, strategy planning, resource allocation

4. Self-Consistency Consensus

Generates multiple independent reasoning chains and selects converged outputs.

pattern: self_consistency
candidate_generation:
  generate_reasoning_paths: 5
aggregation:
  detect_consensus
selection:
  choose_majority_or_highest_confidence

Best For: Summarization, classification under uncertainty, policy interpretation

1. Manager-Worker Pattern

Hierarchical decomposition with central coordination and specialized workers.

• Manager assigns tasks based on worker capabilities
• Workers execute independently with scoped tools
• Results aggregated by manager

2. Debate-Arbitration Pattern

Multiple agents propose competing solutions, arbiter selects best.

• Improves decision quality under uncertainty
• Reduces single-agent bias
• Requires explicit scoring criteria

3. Ensemble Integration Pattern

Combines specialist outputs through consensus or weighted voting.

• Domain specialists contribute independently
• Outputs integrated via majority vote or confidence weighting
• Improves robustness and coverage