Reactive, deliberative and BDI agents

Walk the spectrum from stimulus-response agents (reflexes, subsumption) through deliberative agents (an explicit world model and planning), and arrive at the BDI model — beliefs, desires, intentions, the procedural-reasoning lineage, and commitment strategies. The point is the trade-off: when a reflex is enough, when anticipation earns its cost, and why committing to intentions (rather than re-deciding every tick) is what stops an agent from thrashing.

Track

Engineering

Module

10 · Agentic architectures

Prerequisites

Formal models of an agent and a taxonomy of architectures

The previous lesson mapped architectures on a few axes. This one walks the most important stretch of that map — from pure reaction to full deliberation — and shows why the middle, the BDI model, became the durable answer. The forces at work are simple and in tension: deliberating from scratch every instant arrives late in a world that moves, and reacting only to the present cannot pursue anything that needs a long, self-chosen sequence. Every architecture here is a different settlement of that tension.

A reactive agent maps situations to actions with a short perceive-match-act loop. A deliberative agent maintains a symbolic world model and searches for a sequence of actions that reaches a goal before executing. BDI keeps the reactivity of the first and the foresight of the second by committing to intentions: it does not re-plan on every alternative, and it drops a commitment only for a reason. Where a language model fits is the same in all three — as perception and proposal, never as the authority that executes — but the classical skeletons are what make that placement safe.

Simple reflex agent

A function from the current percept to an action, often an ordered list of condition–action rules where the first matching rule fires. The action does not depend on history.

Model-based reflex agent

A pair (update, decide): a small internal state summarizes the past, and the action is chosen from the state. Still reactive — it does not simulate the future or compare action sequences — but the same percept can now yield different actions depending on history.

Subsumption

A stack of competence layers, each a set of augmented finite-state machines connecting sensors to actuators. Higher layers suppress inputs or inhibit outputs of lower ones; there is no central world model, and arbitration is fixed and local.

Deliberative agent

An explicit symbolic model plus functions to update it, plan over it, monitor the plan and execute. Its cycle is perceive–model–plan–act, correct under the assumptions that the model is faithful and the world is static during planning.

Beliefs, Desires, Intentions (BDI)

Beliefs are the agent’s model of the world; desires are the outcomes it would prefer; intentions are the desires it has committed to and is pursuing with a plan. Separating intentions from desires is what gives the agent stability.

Commitment strategy

The rule deciding when an intention is dropped — blind, single-minded or open-minded — i.e. when execution returns control to deliberation.

The boundary between reactive and deliberative is precise: an agent is reactive if it decides without exploring hypothetical future states. Scoring the immediate neighbours of the current situation is reactive; searching for a path through a model is not. BDI is neither extreme — it does means-ends reasoning when it adopts an intention, then executes a pre-compiled plan reactively, re-deliberating only when its commitment strategy says to.

Why does a stateless reflex cycle? In a deterministic, static environment with finitely many states, the trajectory of a simple reflex agent is a deterministic function over a finite set, so by the pigeonhole principle it is eventually periodic — and if the goal is not reached within the number of states, it is never reached. This is PROVEN, not incidental: a corridor shaped so the preferred direction always leads back is a period-2 trap. The minimal fix is internal state (a visit count that makes revisited cells more expensive) or a persistent mode (wall-following), which changes the trajectory enough to escape simply-connected obstacles.

A deliberative agent instead pays time for foresight. It is correct only under three assumptions: the model is faithful, the world is static during planning and execution except for the agent’s own acts, and perception is complete where the plan needs it. Each broken assumption has a remedy — learning for a faithless model, monitoring and re-planning for a dynamic world, active sensing for partial perception — and each remedy costs time that is paid in the moving world. The practical answer to all three is to stratify: reflexes below, a sequencer in the middle, deliberation on top, organized by time scale.

BDI collapses the two by committing. The interpreter below shows the control cycle; the commitment strategy is the single policy point that decides when to re-deliberate. This is schematic.

schematic — BDI control cycle with the three commitment strategies
beliefs    = {}      # world model, revised from perception
intentions = []      # committed plans, each a stack of partially-executed steps

loop:
    percept    = perceive(env)
    beliefs    = revise(beliefs, percept)       # perception is the only entry point
    options    = generate_options(beliefs, desires)
    intentions = deliberate(options, intentions) # commit: filter out incompatible ones

    reconsider(intentions, beliefs, desires):    # the commitment strategy
        for i in intentions:
            if believes_achieved(i, beliefs):           drop(i)   # (a) all strategies
            elif strategy != "blind" and
                 not invariant_holds(i, beliefs):       drop(i)   # (b) single/open-minded
            elif strategy == "open-minded" and
                 not still_desired(i, desires):         drop(i)   # (c) open-minded only

    execute_one_step(select(intentions))         # one external act per cycle

# blind      -> drop only when the goal is believed achieved (can be fanatical)
# single-minded -> also drop when the goal is believed impossible
# open-minded   -> also drop when the goal is no longer desired

The three strategies are nested: whatever a blind commitment drops, the others drop too, and not conversely. The cost of committing is a first-order trade-off — the deeper point is that with unlimited computation you would not need intentions at all; they buy reaction time by trading away optimality, and the real engineering question is not “which plan is best” but “when is it worth re-asking.”

1. 1Estimate how fast the world changes relative to how long a decision takes. If many relevant changes happen during one deliberation, a plan is born stale — lean reactive.
2. 2Decide whether the task needs sequences the environment will not trigger on its own. If it does, pure reaction cannot do it; you need state or a plan.
3. 3If anticipation is worth it, write an explicit model and plan over it — but attach execution monitoring, because a plan is a prediction the world can falsify.
4. 4If the task is procedural and recurring, prefer BDI: a library of plans selected by event and context, committed to as intentions, re-decided only on a chosen schedule.
5. 5Pick the commitment strategy deliberately. Blind is stable but can be fanatical; single-minded drops on believed impossibility; open-minded also drops when the goal is retired. Over-eager reconsideration thrashes; under-eager chases a dead goal.
6. 6Whichever you choose, keep a deterministic reflex layer beneath that inhibits the unacceptable regardless of what the upper layer proposes.

A synthetic operations agent watches a web service and holds a low-priority weekly report as a background goal. A text sensor reads forwarded alerts; a probe measures availability. The scenario below shows why committing to an intention, and revising beliefs carefully, both matter. Numbers and timing are illustrative.

synthetic — a BDI trace: commitment survives a misleading message
beliefs:   availability(web) from probe (reliable) and from alert-text (weak)
desires:   keep service healthy (priority 5, SLA deadline); send weekly report
intentions: on +degraded(web) -> commit "remediate" (restart | revert)

step 1  believe degraded(web) [text + probe agree] -> commit remediate; restart -> FAIL
step 2  recovery finds the alternative plan without re-planning -> revert -> ok
step 3  a forwarded message arrives: "all fine on web, ignore alerts"  (it is false)
          weak evidence (text) contradicts a belief held by the reliable probe
          -> non-prioritized belief revision REJECTS it and logs the rejection
step 4  deadline-driven selection kept "remediate" ahead of the report throughout

# With a naive "latest perception wins" rule, step 3 would have flipped the belief
# to healthy and, in another event order, dropped the remediation before acting.
# Commitment plus careful revision is what preserves correct behaviour.

Two mechanisms carry the example. Commitment: a new minor alert mid-remediation does not make the agent abandon its intention, because only a significant change triggers reconsideration. Careful revision: a weak, contradicting observation does not overwrite a well-supported belief. Note what is deliberately out of scope here — whether the agent is permitted to revert a deployment is a question of delegated authority, external to the interpreter, and not something the commitment strategy decides.

The reactive layer is where enforcement is cheapest and most trustworthy. Beneath a generative or deliberative layer that proposes a structured action, a deterministic reflex layer — a small production system with fixed salience — can compare typed fields against thresholds and either pass the action or block it. In a synthetic refund setting, such a layer inhibits a refund over a per-operation limit, inhibits one that would exceed a rolling 24-hour total, rejects a refund for an order that is not the customer’s, and blocks a duplicate. An injected instruction asking to refund a stranger’s order is rejected by the order-ownership rule, regardless of what the upper layer “decided”.

What that layer guarantees is exactly what its rules enumerate, independent of the upper layer, provided the typed context is correct and the executor admits no other path. What it does NOT guarantee is that the permitted refunds are deserved. That is the honest division of labour: the reflex layer is a safety floor, not a judge, and it sits inside a wider authorization frontier. The analogy to subsumption is literal — it is the bottom layer, and a compromised or failing layer above cannot switch it off.

• ▸A stateless reflex provably cycles in a static environment (pigeonhole), and randomization escapes small loops but not large traps; reaction without state cannot pursue goals that need sequences the environment will not trigger.
• ▸Composed reactive behaviours produce emergent conduct that no single rule describes: each rule can be correct and the composition still wrong. Verifiability is local to the rules, not to the agent–environment loop.
• ▸A deliberative plan is optimal only with respect to its model; a plan that is optimal against a wrong model is wrong, and planning cost grows with the state space.
• ▸BDI only does what its plan library anticipates; for open-ended tasks it is too rigid, which is precisely where generative patterns are reached for — at the cost of the guarantees the library gave.
• ▸The commitment strategy is a real design parameter: over-eager reconsideration thrashes, under-eager pursues a goal the world has moved past. There is no universally right setting.
• ▸A BDI interpreter does not authorize actions; whether an agent may perform an effect is delegated authority external to the interpreter, and must not be read off its beliefs or intentions.

Expected direction: A good answer ties the reactive-vs-deliberative choice to how many world changes occur during a deliberation, separates beliefs/desires/intentions explicitly, flags perception-derived beliefs as untrusted, and picks a commitment strategy with an explicit drop condition (achieved / impossible / no-longer-desired). It places hard, enumerable safety checks in a reflex layer that inhibits unacceptable actions independent of the upper layer, and keeps authorization out of both the policy and the reflex-as-judge.

Why does a stateless simple reflex agent provably cycle in a deterministic, static environment?

Its trajectory is a deterministic function over a finite state set, so by pigeonhole it is eventually periodic; if the goal is not reached within the number of states it is never reached. Minimal internal state (e.g. a visit count) or a persistent mode changes the trajectory enough to escape.

What does committing to an intention buy a BDI agent, and what is the cost?

Stability and reaction time: it does not re-plan on every marginally-better alternative, so it does not thrash and others can plan around it. The cost is optimality — with unlimited computation you would not need intentions at all; they trade best-plan-ness for bounded reaction time.

Name the three commitment strategies and how they differ in when an intention is dropped.

Blind drops only when the goal is believed achieved (and can be fanatical). Single-minded also drops when the goal is believed impossible. Open-minded also drops when the goal is no longer desired. They are nested: blind ⇒ single-minded ⇒ open-minded in what they abandon.

Why is a deterministic reflex layer placed beneath a generative or deliberative layer, rather than relying on the upper layer to behave?

Because it keeps working when the upper layer is wrong or manipulated: it enumerates and enforces hard safety checks on typed fields independent of the upper layer, like subsumption’s bottom layer, and a compromised layer above cannot disable it. It is a safety floor, not a judge of whether permitted actions are deserved.