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:
- Restate your idea in my own words
- Explain how it lines up with existing architectures and systems
- Point out what looks genuinely distinctive
- Highlight important gaps / pitfalls
- 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:
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:
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:
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:
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.