Architectures

Most agent failures are not prompt failures. They are architecture failures. The wrong loop creates the wrong behavior, no matter how good your model is. This lesson is a practical map of the main agent architectures and the signals that tell you which one to use.

Three Core Architectures

1) Reactive Loop

A reactive agent observes input and takes the next best action without long-term planning. It is fast, cheap, and easy to test. It is also limited when tasks require multi-step reasoning.

Best for: chat support, triage, simple tool calls.

2) Deliberative Planner

A planner creates a multi-step plan and executes it, often with checks or revisions. It is slower and more expensive but handles complex tasks better.

Best for: research, multi-step automation, document generation.

3) Hybrid Loop

A hybrid agent starts with a light plan and then adapts on every step. This is the most common production pattern because it balances speed and reliability.

Best for: most production agents.

Pattern: Plan-Execute-Reflect

The plan-execute-reflect loop is a reliable default. It introduces structure without forcing the agent into a brittle plan.

type Step = { tool: string; input: Record<string, unknown>; intent: string };

type Plan = {
  goal: string;
  steps: Step[];
  successCriteria: string[];
};

async function planExecuteReflect(state: AgentState) {
  const plan = await proposePlan(state); // model suggests 3-6 steps

  for (const step of plan.steps) {
    const result = await executeTool(step.tool, step.input);
    state = updateState(state, step, result);

    if (isGoalMet(state, result)) break;

    if (shouldReplan(state, result)) {
      return planExecuteReflect(state); // replan on new evidence
    }
  }

  return state;
}

Notice the replan gate. Without it, plans become brittle and waste tokens.

Architecture Selection Checklist

Use this quick test to decide which architecture to start with:

• Task length: Under 2 tool calls? Use reactive.
• High uncertainty: Use hybrid so it can adapt.
• Legal or financial risk: Use deliberate planning with explicit checks.
• Need for speed: Use reactive with strict budgets.

In practice, you can start reactive and add planning when you see failures. Do not over-architect from day one.

Decision Matrix