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.
MAKE THE IDEA PRECISE
The mathematics.
| Symbol | Meaning |
|---|---|
| j | Index of a candidate proposal |
| score_j | Task-specific score under a stated evaluation rule |
| argmax | Index of a maximum-scoring element |
Build the equation, step by step
- List candidate actions that are currently permitted. Scores across candidates need a comparable meaning or a defined arbitration policy.
- Choose the largest score using argmax. Resolve ties explicitly if reproducibility or fairness among choices matters.
- 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.
- Run the example with move scored 0.95 but forbidden. Identify the winning eligible proposal.
- For a separate case, forbid every proposal. Trace the empty-set branch without calling max on an empty list.
- 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
- 20.1.1 Perception, attention and prediction
- 20.1.2 Memory, planning and reasoning
- 20.1.3 Learning, motor control and self-monitoring
- 20.1.4 Hierarchical organization and shared representations
- 20.1.5 Behavioral competence versus anthropomorphic labels
20.2 Agentic systems · Outline
- 20.2.1 Tools, observations and bounded actions
- 20.2.2 State machines, planners and LLM-based orchestration
- 20.2.3 Verification, provenance and feedback
- 20.2.4 Recovery from tool or perception errors
- 20.2.5 Compare agentic complexity with a fixed workflow
Integration and evidence
20.3 Multiple timescales · Outline
- 20.3.1 Reactive, deliberative and developmental processes
- 20.3.2 Communication and shared state
- 20.3.3 Resource allocation and scheduling
- 20.3.4 Continual learning and forgetting
- 20.3.5 Audit logs and interpretable failure traces
20.4 Architecture evaluation · Outline
- 20.4.1 Task suites and transfer tests
- 20.4.2 Component ablations and bottleneck analysis
- 20.4.3 Generalization outside training conditions
- 20.4.4 Reliability and bounded autonomy
- 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.
Primary paper / author manuscript
Vaswani et al. (2017): Attention Is All You Need ↗
Read after matrix multiplication and optimization. Reconstruct query-key-value shapes and distinguish sequence modeling from embodied control.
Primary research / versioned manuscript
Hafner et al.: Mastering Diverse Domains through World Models ↗
Read after latent dynamics and actor-critic learning. Evaluate imagined rollouts, model errors, and the scope of reported task results.