Rule-based action selection

As programs start to behave like agents, they need a clear way to decide what to do next. In classical agents, those decisions are not guessed or learned. They are chosen by applying explicit rules to known state. This lesson introduces rule-based action selection as a simple, predictable way to turn state into behavior.

What rule-based decision logic is

Rule-based decision logic means choosing actions by checking conditions and following predefined rules. Each rule describes a situation and the action that should be taken when that situation occurs. There is no uncertainty involved. Given the same state, the same rule will always be chosen.

This style of decision-making is common in early agent systems and automation scripts because it is easy to reason about and easy to test.

Expressing rules as conditional checks

In Python, rules are usually expressed as conditional checks. These checks inspect values in the agent’s state and evaluate to either true or false. When a condition is true, the corresponding rule applies.

A rule might check whether a queue is empty, whether a file exists, or whether a counter has reached a certain value. Each check answers a simple yes-or-no question about the current state.

if pages_to_generate == 0:
    action = "idle"

Mapping conditions to actions

Once a condition is checked, it is mapped directly to an action. The action can be represented as a string, a function call, or some other symbolic value that the rest of the program understands.

This mapping makes the intent of the rule clear. When the condition holds, the agent commits to a specific behavior without further reasoning.

if pages_to_generate > 0:
    action = "generate_page"

Selecting actions deterministically based on state

Rule-based systems are deterministic by design. The agent reads its current state, evaluates rules in code, and selects an action based only on those values. There is no randomness and no interpretation.

This determinism makes behavior predictable. It also makes debugging straightforward, because a decision can always be traced back to a specific condition in the code.

Implementing simple rule tables in code

As the number of rules grows, it can be useful to represent them as a simple rule table. A rule table pairs conditions with actions in a structured way, rather than spreading logic across many if statements.

One common approach is to store condition–action pairs and evaluate them in order.

rules = [
    (pages_to_generate > 0, "generate_page"),
    (pages_to_generate == 0, "idle"),
]

for condition, action in rules:
    if condition:
        selected_action = action
        break

This pattern keeps decision logic compact and makes the set of rules easy to inspect.

Conclusion

At this point, we are oriented to how rule-based action selection works. We know what it means to express decisions as rules, how to check conditions against state, and how to map those conditions to actions in a deterministic way. This provides a solid foundation for building predictable agent behavior without introducing learning or probabilistic reasoning.