HyperAgent — Cognition Engine: Building an AI System That Thinks Like a Human

The HyperAgent Cognition Engine is a dual hyper-agent architecture in which two complete cognitive pipelines — a Solver and a Critic — work together, combining lateral thinking, domain-expert reasoning, independent verification and iterative refinement in a single coherent system. Each agent in this architecture runs on its own model, with its own temperature, reasoning effort and hyperparameters tuned to the nature of its specific task.

This isn’t a single design pattern. It’s several proven patterns — orchestrated together into something that behaves more like a mind than a workflow.

Author’s note: The architecture presented below is a personal vision and design; it represents my specific take on how to structure a Cognition Engine. There’s plenty of research across the industry exploring similar concepts and frameworks in the AI ecosystem.

The Big Picture: Two Minds, One Engine

The architecture is built around two hyper-agents, each containing a complete cognitive pipeline:

Hyper-Agent 1 — The Solver: Takes a user’s input and produces a rich, thoughtful answer. It doesn’t just retrieve or generate; it observes, recalls, thinks laterally, synthesises, evaluates, plans and delivers.
Hyper-Agent 2 — The Critic: Receives that answer and puts it through an independent, adversarial evaluation pipeline. It challenges, verifies and either approves the answer or sends it back for refinement.

The hand-off between them creates a feedback loop that mirrors something deeply human: our ability to produce ideas and then evaluate them relentlessly.

Hyper-Agent 1: The Solver Pipeline

The Router — A System 1 / System 2 Gate

Every request starts at the Router, which acts as the architecture’s first decision point — inspired by Daniel Kahneman’s dual-process theory. It classifies the input and decides:

Fast Path: Simple, factual or low-complexity queries are routed to the Fast Answer agent, which responds quickly with minimal overhead. Think of it as System 1: fast, intuitive, efficient.
Deep Path: Anything that needs analysis, reasoning or nuance enters the full cognitive pipeline. This is System 2: slow, deliberate, thorough.

This gate is critical for efficiency. Not every question needs the full engine, and wasting deep reasoning on trivial queries is both slow and expensive.

The Contextualizer — Grounding in Reality

Once on the Deep Path, the Contextualizer kicks in. It runs web searches, detects knowledge gaps and determines whether the system has enough information to proceed. If it doesn’t — if there’s ambiguity or missing context — it routes to a Wait for User node, bringing the human back in before continuing.

This matters: the system knows what it doesn’t know. Instead of hallucinating its way through the gaps, it asks.

Observer → Reflector::Recall — Seeing and Remembering

The Observer analyses the grounded input, extracting structure, intent and domain signals. Then Reflector::Recall searches memory — pulling relevant past interactions, known patterns and stored knowledge to inform the current task.

Together, they answer two questions: What is this? and What do I already know about it?

The Lateral Thinking Engine — Where Creativity Lives

This is the heart of the Solver, and it’s where the architecture gets genuinely interesting.

Inspired by Edward de Bono’s lateral thinking techniques, the engine deploys six specialised sub-agents, each attacking the problem from a fundamentally different angle:

Agent	Role
Provocateur	Random connection to find blind spots — forces unexpected associations.
Challenger	Breaks assumptions in how the problem is framed.
Inverter	What would the WRONG answer look like? Works backwards from failure.
Analogist	How do other domains solve this? Cross-pollination of ideas.
Fractionator	Breaks things down by who benefits and who loses — structural analysis.
Escapist	Escape the “this answer is fine” trap — push beyond satisficing.

These six agents generate alternative perspectives. Then the Brainstormer Synthesis agent distils their outputs — 5 alternatives from 6 techniques — and hands them to the Thinker.

But here’s the nuance: the Thinker doesn’t just pick the best idea. It’s guided by Expert Lenses — personas such as Logician, Scientist, Engineer, Artist and Communicator — selected dynamically based on the Observer’s domain signals. A maths problem activates the Logician; a UX question activates the Artist and the Communicator.

And the hyperparameters reflect this. Analytical lenses run at low temperature (T≈0.1) for precision. Creative lenses run hot (T≈0.9) for divergence. Every agent is configured independently — model, temperature, reasoning effort — to match the cognitive mode it represents.

Reflector::Evaluate — The Quality Gate

Before anything is delivered, the Reflector::Evaluate agent runs a quality gate across N dimensions. Is the answer accurate? Complete? Well structured? Does it address the original intent? This is the Solver’s internal self-check — the “wait, is this actually good?” moment before committing.

Executor::Plan → Executor::Execute → Deliver

The answer that survives moves into the execution phase. Executor::Plan structures the delivery. Executor::Execute produces the formatted output. And Deliver packages the final draft along with lateral alternatives — because sometimes the second-best idea is the one the user actually needed.

Then the whole output is handed to the Critic.

Hyper-Agent 2: The Critic Pipeline

If the Solver is the creative mind, the Critic is the sceptical peer reviewer. It runs its own complete cognitive pipeline — not a simple thumbs-up/thumbs-down check, but a deep, independent evaluation.

Critic Fast — The Quick Sanity Check

Just like the Solver’s Router, the Critic has a fast path. Critic Fast does a lightweight fact check. If the answer is clearly solid, it approves it and the system finishes. If something smells off, it escalates to the deep evaluation path.

Deep Evaluation Pipeline

When the Deep Path is triggered, the Critic mirrors the Solver’s cognitive depth:

The Critic Observer scans the Solver’s output for claims, structural integrity and coverage gaps. The Critic Reflector cross-checks those claims against its own knowledge base — verifying independently, without blindly trusting the Solver’s work.

The Critic’s Lateral Thinking Engine

The Critic has its own set of six lateral thinking agents — the same six archetypes (Provocateur, Challenger, Inverter, Analogist, Fractionator, Escapist) — but now aimed at the answer rather than the question. They challenge the Solver’s output from six angles:

Is there a blind spot? (Provocateur)
Are there hidden assumptions? (Challenger)
What would make this answer wrong? (Inverter)
How would other domains judge quality? (Analogist)
Who benefits from this approach and who loses? (Fractionator)
Is “this answer is fine” really good enough? (Escapist)

The Critic Brainstormer synthesises these into 5 evaluation perspectives, feeding the Critic Thinker (which builds evaluation hypotheses and surfaces critical issues) and the Critic Executor.

The Synthesizer — Verdict Time

The Critic Synthesizer is the point of convergence. It takes in everything:

The Observer’s claims and gaps.
The Reflector’s knowledge checks.
Five lateral evaluation perspectives.
The Thinker’s hypotheses.
The Executor’s verification data.

All condensed into a single verdict with a numerical score.

If the score reaches the threshold (≥ 0.75), the answer is approved and flows to Reflector::Learn, which stores lessons from the interaction for future recall. End of the pipeline.

If the score falls short, the Critic Refiner rewrites the answer using the full analysis, and the revised output re-enters the evaluation pipeline from the top. This creates an iterative refinement loop that continues until convergence.

Per-agent Hyperparameter Configuration

One of the most important design decisions in this architecture: every agent has independently configurable hyperparameters.

This isn’t a monolithic system running one model at a single temperature. It’s 19 independently configurable agents, each tuned for its specific cognitive role:

Analytical agents (Observer, Reflector, Executor) run on precise, low-temperature models or with high reasoning effort — precision matters more than creativity.
Creative agents (the Lateral Thinking sub-agents, especially Provocateur and Escapist) run at high temperature.
Synthesis agents (Brainstormer, Thinker, Synthesizer) run with moderate settings — they need to be creative enough to see connections but disciplined enough to stay coherent.
Routing agents (Router, Critic Fast) use lightweight, fast models — they make binary or low-cardinality decisions and don’t need heavy reasoning.

The system is multi-provider by design, drawing on Azure OpenAI (GPT models) and Azure AI Foundry (Claude, Mistral, Phi) depending on what each agent needs. A fast Router might use GPT-5.4 nano. A deep Thinker might use Claude Opus 4.6.

This is where the analogy with human cognition becomes concrete: your brain doesn’t use the same neural process for pattern recognition as for logical deduction. Different cognitive modes demand different computational profiles. This architecture respects that.

Design Patterns at Play

This system doesn’t invent from scratch. It composes proven patterns:

Dual-process theory (Kahneman) → the Router’s System 1 / System 2 gate.
Lateral thinking (de Bono) → sub-agents inspired by the Six Thinking Hats in both pipelines.
Generator-Critic loops → the Solver produces, the Critic evaluates, the Refiner improves.
Chain of thought / multi-step reasoning → the Observer → Reflector → Thinker → Executor pipeline.
Expert mixture → domain-specific Expert Lenses activated by context signals.
Adversarial evaluation → an independent Critic pipeline with its own lateral thinking.
Iterative refinement with convergence → score-based approval with diminishing-returns detection.
Memory and learning → Reflector::Recall and Reflector::Learn for persistence across sessions.