Learning: A Cognitive Architecture Process
How experience changes representations, memory, reasoning, and action
GPT-like models make this distinction critical: generating from learned knowledge is not the same as continuously learning from new experience. Psychology and neuroscience tend to be representation-first: they ask what changes in the mind or brain when an organism learns. AI/ML tends to be optimization-first: it defines a loss, reward, or objective, then updates parameters so performance improves. In deep learning, this is especially clear: a loss is backpropagated, parameters change, and representations shift as a result. Backpropagation was explicitly introduced as a procedure for learning representations by propagating errors through networks. These are not competing accounts so much as two views of the same process. Learning can be understood as representation change through experience, but engineered systems usually produce that change through optimization.
That distinction matters for cognitive architecture. A cognitive architecture treats intelligence not as one model, but as a coordinated system: perception, representation, memory, learning, reasoning, action, and feedback working together. This article frames this as a blueprint for building intelligent systems beyond isolated models, emphasizing closed-loop coordination among perception, memory, reasoning, and action.
Rather than treating learning as another module in a list, it is more useful to follow the update through the system: What is learning? What changes? What causes the change? When should a system learn? How much learning does it need? And what does that imply for the architecture around it?
What is learning?
For intelligent systems, learning can be defined as:
The process by which experience changes a system’s internal state so that future perception, prediction, reasoning, action, or adaptation improves.
This definition works for brains and machines. In humans, the changed internal state may be a memory trace, concept, habit, skill, schema, or neural circuit. In ML, it may be a parameter vector, embedding, policy, latent space, world model, retrieval index, or external memory state. Representation learning research makes this bridge explicit: ML success often depends on learning useful representations of data.
In a cognitive architecture, learning sits between experience and future behavior. Perception supplies the data. Memory stores the result. Reasoning uses it. Action tests it. Feedback corrects it. Learning, in other words, is the update process that keeps an intelligent system from being merely reactive.
Once learning is framed as an update, the next question is straightforward: what, exactly, is being changed?
What changes when a system learns?
Psychology and neuroscience usually classify learning by what kind of representation or behavior changes. Memory-systems research distinguishes declarative memory for facts and events from nondeclarative systems such as skills, habits, priming, and conditioning.
This taxonomy includes non-associative learning, associative learning, declarative learning, procedural and implicit learning, perceptual learning, statistical learning, social learning, and category/rule learning. The point is less the labels than what they imply: biological learning is a family of representation-changing processes, not one universal mechanism. Different learning types therefore call for different memory structures, update signals, timescales, and evaluation methods.
That tells us what changes. Engineered systems are usually organized around the complementary question: what signal causes the update?
What causes the change?
In AI/ML, learning is usually classified by the feedback signal used for update: labels, rewards, demonstrations, preferences, unlabeled structure, or deployment data. Mitchell’s classic ML definition captures this performance-oriented framing: a program learns when experience improves performance on a task under a performance measure.
This includes supervised, unsupervised, semi-supervised, self-supervised, reinforcement, imitation, preference-based, active, online, continual, transfer, meta, federated, evolutionary, and generative learning. Reinforcement learning is especially clear as optimization over interaction: an agent adapts behavior to maximize reward.
AI/ML learning types are mostly organized by update signal and objective function. The practical design implication is to choose the learning type by the feedback that is available, how often the system must update, the safety risk of those updates, and the memory substrate being changed.
But an update signal only matters if the system has some state to rewrite. That is where learning and memory meet.
Where does the change live?
Learning and memory are closely linked, but they are not the same.
Learning is the process.
It changes the system.
Memory is both input and output.
It provides prior knowledge to learning, and it stores the result of learning.
In a human system, memory may include episodic, semantic, and procedural forms. In an AI system, memory may include model weights, embeddings, context windows, databases, replay buffers, vector stores, logs, symbolic rules, or learned policies.
A useful formula is:
Learning = update operation
Memory = stored state before and after the update
Learning without memory cannot accumulate. Memory without learning cannot adapt.
Learning writes, rewrites, or reorganizes memory; memory gives learning something to start from and somewhere to land.
When should a system learn?
A system needs to learn when fixed behavior is insufficient.
It should learn when the environment changes, when rules are unknown, when hand-coding becomes too expensive, when feedback is available, when personalization matters, or when long-term adaptation is required. Examples include a robot adapting to terrain, a recommender adapting to a user, a diagnostic system adapting to new failure patterns, or a design assistant learning from repeated engineering choices.
But not everything should learn. If the task is stable, safety-critical, fully specified, legally constrained, or easily handled by a deterministic rule, learning may introduce unnecessary risk. Sometimes the right architecture is reactive. Sometimes it is adaptive. Sometimes it needs both.
The design principle is simple: Learn only when adaptation is worth the cost, uncertainty, and governance burden.
Once learning is justified, the next question is proportionality: how much learning machinery does the system actually require?
How much learning does the system need?
Learning should be only as complex as the system’s required adaptation.
A simple threshold update may be enough for a thermostat-like controller. Online learning may be enough for changing data streams. Supervised learning may be enough for classification. Reinforcement learning may be needed when the system must act and learn from delayed consequences. Continual learning becomes necessary when old knowledge must be preserved while new knowledge is added. Federated learning becomes relevant when data cannot be centralized. Active learning helps when labels are costly; transfer learning helps when labeled data is scarce in a target domain.
The wrong question is: “Can we make it learn?”
The better question is: “What must change, from what signal, at what timescale, under what constraints?”
The complexity of learning should match the complexity of adaptation required. That choice also determines when learning happens – during training, at deployment, continually, or not at all – and where to draw the boundary between learning and using what has already been learned.
What does this imply for a cognitive architecture?
Learning is changing the system.
Application of learning is using what has already changed.
A model being trained is learning. A trained model making a prediction is applying learned knowledge. A person practicing a procedure is learning. A person executing that mastered procedure is applying learning. A robot updating its policy after failure is learning. A robot using its current policy to complete a task is applying learning.
This distinction matters in cognitive architecture because learning and application have different requirements. Learning needs feedback, evaluation, and update rules. Application needs retrieval, inference, control, and action selection. Mixing them can make systems unsafe: a system that keeps learning during deployment may drift; a system that never learns may become obsolete.
Learning modifies competence; application expresses competence.
Final takeaway
A cognitive architecture therefore has to decide not only what can learn, but when updates are allowed, where state is stored, how feedback is evaluated, and how learned state is exposed to reasoning and action.
Seen this way, learning is not a single module that can be bolted onto intelligence. It is a cognitive architecture process: experience enters through perception, modifies memory and representation, shapes reasoning and action, and is corrected through feedback.
In psychology and neuroscience, learning is representation-centric.
In AI/ML, learning is optimization-centric.
For intelligent systems, both views are necessary:
Learning is the controlled transformation of memory and representation through experience, so that future behavior improves.
Get in touch
Have we piqued your interest? Get in touch if you’d like to learn more about Autodesk Research, our projects, people, and potential collaboration opportunities
Contact us
