Early-Stage Idea: A Cognitive Architecture Built on Attention and Graph Traversal

John6666
Fri, 05 Dec 2025 00:27:42 +0000

I had the search agent run the search repeatedly and think it over, but it didn’t come up with any grounds to deny its research value. So, probably fine.

Short answer: yes, this absolutely has potential research value. It overlaps with existing work (so it’s not “from nowhere”), but the combination you’re proposing is coherent, timely, and, if you sharpen it, could become a serious small research program—especially in the context of LLM-based agents and structured memory.

Below I’ll:

1. Restate your idea in my own words

2. Explain how it lines up with existing architectures and systems

3. Point out what looks genuinely distinctive

4. Highlight important gaps / pitfalls

5. Suggest concrete next steps and readings

I’ll keep the language informal but precise so you can reuse pieces in a post or a write-up.

1. Restating what you’re proposing

You’re proposing a cognitive architecture where the “mind” is a dynamic, multi-modal knowledge graph, and cognition is what happens when activation and attention move around this graph.

In more explicit terms:

Representation

Everything is a node: concepts, events, actions, rules, goals, emotions, self-state variables, decision heuristics.

Edges are directed and weighted, encoding semantic relations, causal links, temporal structure, preconditions/effects, motivational links, etc.

This graph is multi-modal: language, perception, internal signals all become structured propositions embedded into the graph.

Process / “thinking”

Nodes carry activations. Activation spreads along edges with some decay.

Attention is not a single pointer; it’s a cluster of highly active nodes—a local “hot spot” in the graph.

The Focus of Attention (FoA) is the currently dominant cluster, which you treat as the system’s “current thought” or working content.

There is no top-down scripted controller; instead, the control flow emerges from activation dynamics, task relevance, and the current internal state.

Memory structure

Semantic memory: the stable concept/relationship part of the graph.

Episodic memory: sequences of events / propositions linked over time, possibly with event boundaries detected from semantic shifts.

Self-model: internal variables as graph nodes (emotional tone, arousal, uncertainty, confidence, workload, etc.) that modulate activation diffusion and thresholds globally.

Mode parameter (DMN-like vs CEN-like)

A continuous scalar controls whether the system behaves in a more:

divergent, associative, “Default Mode Network-like” regime (broad diffusion, looser thresholds, more episodic and self connections), or

convergent, focused, “Central Executive Network-like” regime (narrow diffusion, strong goal constraints, local reasoning).

Importantly, you don’t swap architectures; you just change parameters, so the same graph machinery yields different cognitive styles.

Action and control

Some nodes encode decision-theoretic features (expected utility, risk, etc.), some encode prospective intentions (delayed intentions that should fire later), and some encode “action templates” that can be instantiated as external actions when certain patterns in the FoA are present.

That is: a single, unified graph for world knowledge, self state, and intentions; spreading activation + attention as the control mechanism; and a mode parameter that smoothly shifts the reasoning style between free association and goal-directed focus.

2. How this relates to existing work

You are not reinventing the wheel blindly; you’re stepping into a space with existing architectures and systems. That’s good. It means you can position your work rather than defend it as totally new.

2.1 Classical cognitive architectures

There’s a long tradition of architectures that try to unify perception, memory, and action in one framework: ACT-R, Soar, CLARION, LIDA, OpenCog, SPA/Spaun, Sigma, and many more. Surveys like Kotseruba & Tsotsos’s review of 84 architectures give a good overview. (Science Direct)

Two are especially close to what you’re doing:

LIDA (Learning Intelligent Distribution Agent)

Implements Global Workspace Theory: perception builds a “situational model”; attention codelets select parts of that model; those coalitions compete for access to a global workspace; the winner is broadcast, driving learning and action. (Science Direct)

It has separate semantic and episodic memories and includes motivations and emotions in the architecture. (digitalcommons.memphis.edu)

This is very close to your idea of a current FoA emerging from a competition among candidate clusters and then driving further processing.

OpenCog / OpenCog Prime

Uses the Atomspace, a typed, weighted hypergraph of all knowledge and internal state—very similar in spirit to your world+internal knowledge graph.

Has an Economic Attention Allocation (ECAN) subsystem that treats attention as an economic resource distributed over atoms; high-attention atoms get more processing. (Open Cochtit)

ECAN is literally about activation/importance spreading on a graph to control what gets processed, something you’re reinventing in your own way.

So: the shape of your idea—graph memory + activation + attention as control—has solid precedents. That’s a strength, as long as you explicitly say “this builds on X and Y” instead of claiming total novelty.

2.2 Modern LLM agents and graph-based memory

Separately, there is a surge of work on memory mechanisms for LLM-based agents. A 2024 survey (“A Survey on the Memory Mechanism of Large Language Model based Agents”) reviews many designs and classifies memory as episodic, semantic, working, profile/self, etc. (arXiv)

A clear pattern in that survey:

Flat logs and naive vector stores are not enough.

There is growing interest in structured and graph-based memories.

A striking example:

AriGraph (Ariadne agent)

An LLM agent that builds a knowledge graph world model integrating semantic and episodic memory as it explores text-based environments. (arXiv)

The memory graph significantly improves planning and complex task performance over unstructured memory and RL baselines. (arXiv)

AriGraph is basically a subset of what you’re proposing: a semantic+episodic memory graph for an LLM agent, but without the explicit self-model and DMN/CEN-like control.

Your architecture can be framed as:

“A more complete cognitive architecture around the kind of graph-based memory used in AriGraph and other LLM agents, including self-state, attention control, and mode-switching.”

That’s a very reasonable research niche.

3. What looks genuinely interesting / potentially novel

Given that the building blocks are known, the value is in how you combine and sharpen them. Several aspects look distinctive and promising:

3.1 Unified graph including self, affect, and control

Most older architectures treat “emotion” or “self state” as a side-channel or a separate module. You are instead:

Putting emotional tone, arousal, uncertainty, confidence, task load, etc. directly into the same graph that holds world facts and rules.

Letting those internal nodes modulate diffusion, thresholds, and selection across the entire graph.

This gives a single substrate where:

world state,

self state,

goals,

and decision strategies

all live and interact.

That integration is conceptually clean and matches what some modern theories (e.g., cognitive architectures for emotion, LIDA’s emotion/motivation integration) suggest, but you push harder on “all of it is in one graph.” (digitalcommons.memphis.edu)

If you can show, for example, that different “personality parameterizations” of these self nodes produce different reasoning or exploration patterns, that becomes a clear, testable feature.

3.2 Attention as an emergent cluster (FoA) plus a mode parameter

You treat attention not as a single spotlight but as an emergent cluster of highly active nodes (your event/frame), built in layers:

L3: broad neighborhood of candidate nodes,

L2: coherent subclusters,

L1: a tightly bound proposition/event that is “what the agent is thinking about right now.”

That is essentially a graph-shaped global workspace: many candidates compete via activation; a cluster wins; that cluster is the FoA and drives further processing. This parallels LIDA’s coalitions in the Global Workspace, but your three-layer event-frame structure is more explicit and more directly tied to graph structure. (Science Direct)

Then you add:

a continuous mode parameter that reshapes diffusion and selection (DMN-like vs CEN-like). Rather than separate “modules,” you have one mechanism whose behavior smoothly changes with parameters.

If you run toy experiments where varying the mode parameter produces:

more associative, far-reaching paths in one regime, and

tighter, goal-directed paths in another,

you have a neat little story connecting your architecture to the neuroscience literature on Default Mode vs Executive control networks. (Science Direct)

3.3 Prospective-intention nodes (delayed intentions in the graph)

Your prospective-intention nodes (PI-nodes):

store “what to do later,”

have triggers (time, context, conditions), deadlines, and priorities,

gradually increase their activation as deadlines approach or context matches,

compete for attention when they become relevant.

That is an explicit, mechanistic model of prospective memory (remembering to do something in the future), embedded in your graph.

Prospective memory has its own cognitive-psychology literature and is not usually modeled in detail within AGI-like architectures. Embedding it as graph dynamics plus attention (rather than just “if condition then do X”) is a concrete, researchable idea.

A small agent that:

does an ongoing task,

has PI-nodes for delayed tasks, and

uses your attention/activation rules

could already demonstrate something meaningful: e.g., trade-offs between monitoring costs, missed opportunities, and mode settings.

4. Important gaps / pitfalls to be aware of

The big question isn’t “is this interesting?” (it is), but “what could block this from becoming publishable research?” There are a few recurring issues in this kind of work:

4.1 Learning and structural growth

Right now, most of your description is “static architecture + dynamics,” but:

How are nodes and edges created, merged, and deleted over time?

How are edge weights updated based on success/failure or prediction error?

How does the system prevent the graph from exploding with noise and redundancy?

Graph-based agents like AriGraph explicitly address some of this via learned or heuristic update rules over the memory graph. (arXiv)

For research value, you don’t need a perfect solution, but you do need at least:

simple, explicit rules for:

when to create a new node vs reusing an existing one,

basic learning of edge strengths (e.g., increase when a path leads to successful outcomes, decay otherwise),

some forgetting/compression strategy.

Otherwise, reviewers will rightly say “this is a beautiful static design, but it doesn’t tell us how the system learns and stays stable.”

4.2 Missing precise algorithms / equations

Cognitive architecture work that gets taken seriously usually provides:

explicit state variables,

explicit update equations or algorithm pseudocode,

a defined cognitive “cycle” or processing loop. (Science Direct)

You already have the conceptual story. To turn it into research, you need to pin things down:

An activation update rule per node per step

Clear rules for which nodes enter L3/L2, and how clusters are found

What exactly the mode parameter multiplies or adds to

How self-state nodes modulate edge weights or thresholds

These can be simple approximations, but they must be spelled out clearly enough that someone can implement them.

4.3 Scaling and graph explosion

Spreading activation over a large, dense knowledge graph is expensive. OpenCog’s ECAN and newer frameworks like the DeepFunding attention-evaluation project exist precisely to manage and study this. (Open Cochtit)

You will need to think about:

Limiting diffusion radius (depth and activation thresholds)

Pruning or compressing low-importance parts of the graph

Possibly building summaries (like GraphRAG’s communities and summaries) to let attention operate on higher-level structures rather than raw nodes. (Hugging Face)

You don’t have to solve industrial-scale problems, but being aware of the issue and sketching a strategy helps.

4.4 Clarifying what “activation” and “weight” mean

Are your activations:

probabilities,

salience/importance scores,

value estimates,

a mix?

You don’t need to commit to full Bayesian formalism, but you should decide what intuition you want:

If activation ~ salience, then learning rules should look like attention/priming rules (Hebbian-ish, recency-based).

If activation ~ value estimate, then RL-style update rules apply.

If activation ~ belief, more probabilistic/Bayesian thinking might be appropriate.

OpenCog, for example, separates truth values (probabilities + confidences) in its Probabilistic Logic Networks from attention values in ECAN. (Open Cochtit)

You can follow a similar split: “weights encode structure/strength; activation encodes momentary salience.”

5. Concrete advice and next steps

If you want this to become real research rather than “just an interesting idea,” here’s a practical roadmap.

5.1 Narrow to 1–2 sharp questions

Examples:

“Can prospective-intention nodes in a unified graph reproduce basic prospective memory behavior in a text-based agent?”

“Can a continuous DMN/CEN-like mode parameter, acting on a graph-based memory, produce distinct reasoning styles on ‘creative’ vs ‘focused’ tasks?”

“Does integrating self-state nodes into the same graph as world knowledge yield stable, interpretable differences in agent behavior?”

Choose one as your primary goal. The rest can be secondary.

5.2 Build a minimal prototype (even small and ugly)

You do not need big compute. You can:

Use Python + NetworkX or a small graph DB.

Implement:

nodes with activation and type,

weighted edges,

a simple diffusion step,

an FoA selection procedure (top-k nodes → cluster → pick a focal event),

a mode parameter that changes decay and neighbor weighting,

basic PI-node logic.

For environment:

Pick a small text-based game or a toy environment (even a grid with objects and tasks).

Or adapt a simple TextWorld game; AriGraph already uses that framework, and their code is public. (GitHub)

5.3 Compare to simple baselines

To show your architecture matters, compare against:

A baseline LLM agent with simple memory (short window or vector store).

A graph-memory baseline (AriGraph-style memory) without your mode/PI/self mechanisms. (arXiv)

Measure things like:

task success,

number of steps,

how often prospective tasks are forgotten,

how behavior changes as you sweep the mode parameter.

Even small experiments can be compelling if they’re clearly designed and well explained.

5.4 Write it up as “architecture + case study,” not “AGI solved”

When you eventually write a report or a post:

Introduce it as a cognitive architecture proposal for LLM-based agents focused on memory and control.

Anchor it clearly in:

cognitive architecture surveys (for background and terminology), (Science Direct)

LLM-agent memory survey (for relevance to current work), (arXiv)

AriGraph and OpenCog ECAN (for concrete similar systems). (arXiv)

Present your architecture concisely, then show the experimental slice (e.g., PI-nodes or mode parameter) with results.

Be honest about limitations and open questions (learning, scaling, grounding).

That tone will be much better received than “this is a blueprint for AGI.”

6. Bottom line

From a research perspective:

You are not just reinventing something trivial; you’re re-entering a serious line of work (graph-like cognitive architectures, global workspace ideas, attention as control) and connecting it with very current topics (LLM agents, graph-based memory). (Science Direct)

The core ingredients are known, but your particular combination—unified graph with self/affect, structured FoA, continuous DMN/CEN-like mode, and PI-nodes—is coherent and underexplored in modern LLM-agent settings.

The real value will come from:

making the mechanisms mathematically / algorithmically explicit,

implementing a small prototype, and

showing at least one concrete behavioral effect (e.g., prospective memory, mode-dependent reasoning, self-modulated exploration).

So yes: it is worth developing further—especially if you narrow it into a clear, testable piece of research instead of trying to cover the entire AGI problem at once.