Topic Blueprint

Cognitive Architectures: Perception, Deliberation & Action Execution

Cognitive architecture is the biological blueprint for software: it gives an AI agent eyes to observe inputs, a short-term working memory to deliberate, hands to call tools, and a reflection loop to verify its own work before hitting send.

Step 01Perception (Input & Ingestion)

Ingesting webhooks, emails, PDFs, user messages, and system alerts into structured context.

Step 02Deliberation (Reasoning & Planning)

Breaking high-level objectives into sub-goals and deciding which specific tools are required.

Step 03Action (Tool Execution)

Invoking HTTP endpoints, running database queries, sending messages, or triggering scripts.

Step 04Reflection (Output Verification)

Inspecting tool outputs, verifying constraints, and self-correcting errors before final response.

Deep Dive

SECTION 011 of 5

From Raw LLM to an Autonomous Cognitive Agent

A bare LLM (like GPT-4o or Claude 3.5 Sonnet) is essentially a passive text predictor. It has no awareness of time, cannot check whether an API call succeeded, and cannot access private databases. A cognitive architecture wraps this neural network in an operating system loop. The architecture feeds external stimuli into the model, captures its intended tool calls, executes those calls in the real world, and feeds the output back into the model's working memory so it can decide what to do next.

Architectural Principle

Modern AI agents adopt cognitive architecture principles: Perception (ingesting environment context), Deliberation (LLM reasoning and planning), and Action Execution (calling external APIs and tools).

Enterprise Significance

Without clean separation between perception and action, agents suffer from hallucinated tool parameters and premature actions.

Operational Requirement

Always isolate deliberation reasoning steps in a scratchpad before executing state-changing external mutations.

SECTION 022 of 5

Visual Canvas Flowchart: The Perception-Deliberation-Action-Reflection Engine

Here is how this four-stage cognitive loop maps directly onto an n8n workflow canvas:

n8n Canvas Workflow & Agent Execution Visualizer

Agent Flowchart

┌─────────────────────────────────────────────────────────────────────────┐
│                    Cognitive Agent Architecture in n8n                  │
│                                                                         │
│  [1. PERCEPTION]                                                        │
│  ┌───────────────────────┐                                              │
│  │ Webhook Trigger Node  │ ──> (Normalizes incoming JSON/Email payload) │
│  └───────────┬───────────┘                                              │
│              ▼                                                          │
│  [2. DELIBERATION]                                                      │
│  ┌────────────────────────────────────────────────────────┐             │
│  │ n8n AI Agent Node (LLM Brain + Working Buffer Memory)  │             │
│  │ Prompt: "Goal: Reconcile missing invoice payment"      │             │
│  │ Plan: Check ERP -> Check Bank Statement -> Compare     │             │
│  └───────────┬────────────────────────────────────────────┘             │
│              │                                                          │
│              ▼                                                          │
│  [3. ACTION (Tool Calling)]                                             │
│  ┌─────────────────────────┐       ┌────────────────────────┐           │
│  │ Tool 1: NetSuite ERP    │       │ Tool 2: Plaid Bank API │           │
│  │ Query Invoice Status    │       │ Query Cleared Deposits │           │
│  └───────────┬─────────────┘       └───────────┬────────────┘           │
│              │                                 │                        │
│              └────────────────┬────────────────┘                        │
│                               ▼                                         │
│  [4. REFLECTION & VERIFICATION]                                         │
│  ┌────────────────────────────────────────────────────────┐             │
│  │ Self-Correction Check: "Did NetSuite total match bank?"│             │
│  │ If YES -> Mark Paid in ERP & Send Confirmation Slack   │             │
│  │ If NO  -> Post discrepancy flag to Finance Channel     │             │
│  └────────────────────────────────────────────────────────┘             │
└─────────────────────────────────────────────────────────────────────────┘

Swipe horizontally for full architecture⟷

SECTION 033 of 5

Enterprise Case Study: Autonomous Accounts Payable Reconciliation

A multinational logistics firm processed 35,000 freight vendor invoices each month across 8 currencies. Discrepancies between billed fuel surcharges and agreed contract rates required 12 full-time accountants to cross-check rates against contracted master service agreements (MSAs).

Perception

n8n monitored an AP inbox. When an invoice arrived, an Optical Character Recognition (OCR) tool extracted the line items, fuel surcharge rate, and carrier code.

Deliberation

The AI Agent formulated a plan: First fetch the active MSA contract rates from PostgreSQL; second, calculate the approved surcharge based on published weekly diesel index rates.

Action

The agent executed the math and discovered a $480 overcharge on line 4.

Reflection

The agent drafted a polite discrepancy letter citing section 4.2 of the carrier agreement, attached the proof, and placed the invoice on hold in SAP with an audit record.

Results

Automated 82% of invoice clearances without human intervention; recovered $420,000 in erroneous vendor billing within the first 6 months.

SECTION 044 of 5

Cognitive Loop Performance & Stability Matrix

How different cognitive topologies behave under production load:

Architecture Pattern	Loop Structure	Latency (TTFT)	Complexity	Best Suited For
Single-Shot ReAct	Linear Thought-Action	⚡ Fast (1-2s)	🟢 Low	Simple FAQ, data lookups, CRM enrichment
Plan-and-Solve	DAG generated upfront	⏱️ Medium (3-6s)	🟡 Medium	Report writing, multi-step web scraping
Reflexion / Critic Loop	Cyclic evaluator check	Slow (5-10s)	🔴 High	Financial calculations, code generation, SQL queries
Hierarchical Swarm	Supervisor + Subagents	⏱️ Parallel (4-8s)	🔴 High	End-to-end incident triage, enterprise audits

Scroll table sideways→

SECTION 055 of 5

Senior Architect Advice on Cognitive State Drift

When an agent runs more than 4 cognitive iterations, its working memory gets polluted with raw tool responses (stack traces, 2,000-line JSON outputs). The model forgets its original goal and begins hallucinating.

Rule 1

Always summarize tool observations before appending them back into the prompt buffer. Never feed raw 50KB JSON responses back to the LLM.

Rule 2

Implement a hard token-cap circuit breaker. If total accumulated tokens for a single session exceed 16,000 tokens, force an immediate fallback or human handoff.

Senior AI Agent Architect Field Insight

“An agent without a reflection step is just an uncontrolled script that hallucinated permission to run. Always enforce a validation layer before any state-mutating tool executes.”

Interview Q/A based on this topic

Practice Q&A

Agentic AI & n8n