Thinking System Architecture
Three layers — Perception, Cognition, Memory — and how they form one cognitive loop.
Thinking System Architecture
Overview
A thinking system is an architecture that ties input, reasoning, and memory into a continuous loop. Instead of executing instructions linearly, it adapts to context through retrieval and planning.
Three layers. Perception, Cognition, Memory. The rest is how they talk to each other.
Perception — context acquisition
The perception layer turns signals into structured data. Text, visuals, telemetry, user actions — whatever's coming in.
Examples:
- Chat, speech, text inputs
- Cameras, mics, environment sensors
- Logs, analytics, workflow events
Technical role: turns unstructured input into context vectors the reasoning side can read.
Design implication: interfaces aren't UX decoration. They're semantic sensors. Whatever the interface captures is what the system can think about.
Cognition — reasoning and decision
The cognition layer does the thinking. Interprets intent, generates hypotheses, picks the next action.
Implementation:
- LLMs for generative reasoning and inference.
- Agents that extend LLMs with tool use and multi-step planning.
- Execution environments that turn cognitive output into actions.
Characteristics:
- Goal-directed, not rule-based.
- Composition decided at runtime, not compile time.
- Outcomes feed back to refine the next decision.
Design implication: the reasoning chain has to be observable and adjustable. Engineering meets epistemology — the logic itself is part of the product surface.
Memory — retrieval and continuity
The memory layer is what makes a system adaptive instead of reactive. It lets the system recall, compare, learn from prior states.
Components:
- Vector store — embeddings retrieved by similarity.
- RAG — the pipeline connecting model to store.
- Long-term memory — patterns across sessions: logs, knowledge graphs, fine-tuning.
Flow:
Input → Embed → Query → Retrieve → Inject → Generate → Store
Design implication: memory is continuity of identity. Retrieval quality matters more than model size.
The cognitive loop
Perception → Cognition → Action → Memory → Reflection → (loop)
Each pass refines the system's model of the world. The tighter the loop, the more it looks intelligent. Moving from "AI features" to thinking systems is just the optimisation of this loop over time.
Engineering implications
- Architecture is the design problem, not algorithms. Intelligence emerges from how components interact.
- Interfaces are epistemic boundaries. Every schema defines what the system can know.
- Memory coherence equals reasoning stability. Fragmented memory contradicts itself.
- Observability is part of cognition, not a bolt-on. Traces and reflection aren't optional.
Where this goes
Modern stacks — OpenAI Agents, Anthropic tool use, the AI SDK — are early versions of this infrastructure. The trajectory points at composable cognitive environments: reasoning, memory, execution as reusable units.
Not AGI. Just scalable cognition — intelligence that composes, reuses, and audits across contexts.