PART 20 / Research

Cognitive architectures

How can specialized components form an inspectable, adaptable system?

Guided illustrated lesson

What you will learn

Design a modular architecture with explicit state, interfaces, and a task-based evaluation plan.

Before you begin: Hybrid Physical AI; Memory: biological & artificial; World models & prediction; Collective & swarm intelligence

START WITH A QUESTION

Picture this.

A planner says 'move,' a detector says 'obstacle,' and memory says 'this route was clear yesterday.' Combining modules does not automatically resolve their disagreement. The architecture needs explicit rules for which information can influence the next action.

Arbiter
A component or rule that resolves competing proposals.
Constraint
A condition a candidate must satisfy to remain eligible.
Fallback
A specified response when ordinary action selection cannot proceed.

Read for the idea first. Work through the numbers next. Try answering the questions before opening the explanations.

Functions before grand labels

Perception estimates the scene, memory retains relevant information, prediction estimates consequences, and planning proposes actions. These are useful functional descriptions, not claims that a software box has a human-like inner life. Describe its actual inputs, stored state and outputs. A module called reasoning may be a search procedure or a learned text generator; the name alone does not explain its behavior. Clear function boundaries let you replace a component and test what changed.

Rank only eligible proposals

Suppose candidate actions are wait, inspect and move. Scores rank how useful each proposal appears under a stated criterion. Constraints determine which actions are currently eligible. Apply the constraint before selecting the highest score; otherwise a forbidden proposal can win and leave the system without a valid next action. In the example, move has the highest raw score but is masked out because the route is blocked. Inspect then wins among permitted choices.

A score needs a shared meaning

A confidence estimate of 0.8 from one module and a utility score of 0.7 from another are not automatically comparable. Confidence estimates uncertainty; utility expresses preference under an objective. An arbiter needs a defined policy for those different quantities. State tie behavior and what happens when all candidates are rejected. A designated fallback must itself be evaluated for the setting; returning a string called wait is not a universal physical safety guarantee.

Monitor the consequence

After selecting a proposal, compare expected and observed progress. Did the action complete? Is the observation fresh? Did a constraint change during execution? This kind of self-monitoring is an explicit engineering function; it does not imply consciousness. Test disagreement cases and missing-module cases, not just cooperative ones. A system with individually strong components can still fail if their clocks, frames, objectives or state ownership do not agree.

SEE THE RELATIONSHIPS

From structure to behavior.

Hybrid: a labelled conceptual diagram
Figure 20.1 · Hybrid. Original educational diagram; synthetic, not a measured result.
The reasoning pathPerception & memory then Candidate plans then Arbitration & checks then Action & monitoring1. Perception & memory2. Candidate plans3. Arbitration & checks4. Action & monitoring
A learning flow for this part. Follow the assumptions through to an observable result.

MAKE THE IDEA PRECISE

The mathematics.

eligible = {j : permitted(j)}; selected = argmax over eligible j of score_j
Symbols and units
SymbolMeaning
jIndex of a candidate proposal
score_jTask-specific score under a stated evaluation rule
argmaxIndex of a maximum-scoring element

Build the equation, step by step

  1. List candidate actions that are currently permitted. Scores across candidates need a comparable meaning or a defined arbitration policy.
  2. Choose the largest score using argmax. Resolve ties explicitly if reproducibility or fairness among choices matters.
  3. Check the selected action against constraints before execution and monitor its result. A score is a proposal-ranking device, not a proof of correctness or a model of consciousness.

WORK THROUGH THE NUMBERS

Worked example

Wait scores 0.2, inspect scores 0.8, and move scores 0.95. Move is forbidden in this scenario. Filtering first leaves wait and inspect, so inspect wins. The highest raw score is not the highest eligible score.

A small Python experiment.

Python 3 · Standard library only · Synthetic educational example. Run this in your own notebook or a local file.

proposals = [("wait", 0.2, True), ("inspect", 0.8, True), ("move", 0.95, False)]
eligible = [item for item in proposals if item[2]]
chosen = max(eligible, key=lambda item: item[1])[0] if eligible else "no permitted action"
print(chosen)

Read the code as a story

The candidate records include a name, score and permission flag. Filtering creates the eligible set before max chooses its largest score. The else branch handles an empty set explicitly. In this Python example, ties preserve the first eligible candidate's order; a deployed system would need a policy appropriate to its task.

Expected output

inspect

Change one quantity, predict the result, and then run the code again. Explain any difference before adding complexity.

Test your understanding.

Try it: Add a forbidden-action mask. Explain why a high score cannot override the constraint.

Self-check: Why can combining individually strong modules still fail?

Modules may disagree about units, timestamps, uncertainty, objectives or ownership of state. A coordinator can amplify those mismatches. Specify interfaces, test disagreement cases, and measure the behavior of the combined system rather than adding individual benchmark claims.

Where this model stops: Scores are only meaningful if their calibration and constraints are justified.

A research question: Which module causes a failure, and can an ablation isolate that contribution?

Record evidence in your mastery worksheet →

PREDICT / TRY / EXPLAIN

Make the highest score lose

Use paper, a calculator or the Python example. Write your prediction before checking the result.

  1. Run the example with move scored 0.95 but forbidden. Identify the winning eligible proposal.
  2. For a separate case, forbid every proposal. Trace the empty-set branch without calling max on an empty list.
  3. Give wait and inspect equal scores. Decide whether input-order tie breaking is acceptable for your imagined task.
Compare with a worked solution

Inspect wins with score 0.8 in the original case. With all candidates forbidden, the code returns its explicit no-permitted-action message. Equal-score behavior depends on the chosen tie rule. The point is to make these cases deliberate instead of allowing accidental list order or an exception to define system behavior.

CLOSE YOUR NOTES

Can you explain it back?

These questions test the reasoning, not just a remembered phrase. Say your answer out loud or write a sentence first.

01Should a high utility score override an eligibility constraint?

Reveal the reasoning for question 1

Not under this architecture. Constraints define the allowed set; scores rank within it. Changing that policy would require a different explicit design.

02Does a module named memory establish a biological memory mechanism?

Reveal the reasoning for question 2

No. Inspect its actual storage and update behavior. Functional resemblance is useful, but it does not establish mechanistic equivalence.

TAKE THE IDEA WITH YOU

Three things to remember.

  • Specify what a module does rather than relying on its name.
  • Separate eligibility from ranking and handle empty candidate sets.
  • Test module disagreements and monitor action outcomes.

Now we can discuss broader intelligence claims using concrete components and measurements rather than architectural labels.

Continue to Part 21 →

THE NEXT LAYER

Chapter depth map.

This introduction provides a first model. The following chapters are outlines for deeper future editions; their full treatments have not yet been published.

Components and organization

20.1 Functional decomposition · Outline
  1. 20.1.1 Perception, attention and prediction
  2. 20.1.2 Memory, planning and reasoning
  3. 20.1.3 Learning, motor control and self-monitoring
  4. 20.1.4 Hierarchical organization and shared representations
  5. 20.1.5 Behavioral competence versus anthropomorphic labels
20.2 Agentic systems · Outline
  1. 20.2.1 Tools, observations and bounded actions
  2. 20.2.2 State machines, planners and LLM-based orchestration
  3. 20.2.3 Verification, provenance and feedback
  4. 20.2.4 Recovery from tool or perception errors
  5. 20.2.5 Compare agentic complexity with a fixed workflow

Integration and evidence

20.3 Multiple timescales · Outline
  1. 20.3.1 Reactive, deliberative and developmental processes
  2. 20.3.2 Communication and shared state
  3. 20.3.3 Resource allocation and scheduling
  4. 20.3.4 Continual learning and forgetting
  5. 20.3.5 Audit logs and interpretable failure traces
20.4 Architecture evaluation · Outline
  1. 20.4.1 Task suites and transfer tests
  2. 20.4.2 Component ablations and bottleneck analysis
  3. 20.4.3 Generalization outside training conditions
  4. 20.4.4 Reliability and bounded autonomy
  5. 20.4.5 Avoid claims about consciousness from architecture diagrams

Read with the original sources.

These readings support the concepts and deeper investigation. The worked numbers and illustrations above are teaching examples.

Complete source register →

Where next?