Inspiration
Most AI memory systems are designed to retrieve information. They save something a user said and bring it back when it becomes relevant. That is useful, but remembering information is not the same as developing a mind.
MindAssembly began with a different question:
How should an artificial mind change because something happened?
Human experiences do more than add facts to memory. They change the relationships between ideas. A supportive failure can strengthen the connection between uncertainty and learning. A humiliating failure can connect the same uncertainty to shame and danger. Over time, those associations shape beliefs, expectations, and decisions.
Two people can begin with similar knowledge and become very different because they experience different lives. Personalized AI systems may develop in a similar direction: two assistants built from the same base model can gradually behave differently after receiving different histories, feedback, and data. However, users are rarely shown how that adaptation occurs or which experiences caused a system to become more cautious, confident, biased, or rigid.
I wanted to make that hidden process visible.
Instead of trying to reproduce a biological brain or claim machine consciousness, MindAssembly models a smaller and more understandable set of cognitive processes: memory, association, belief formation, and decision influence. It turns those processes into a controlled experiment that anyone can observe.
The central idea became:
Build two identical minds. Give them different lives. Watch who they become.
What it does
MindAssembly is an interactive counterfactual mind laboratory.
The experiment begins with CORTEX-01, a synthetic mind represented as a weighted cognitive graph. Its nodes represent concepts, memories, beliefs, goals, emotions, and tensions. Its edges represent associations between those elements, and every edge has a strength that can change through experience.
The user creates two exact copies of the original mind:
- CORTEX-01A
- CORTEX-01B
Both copies begin with the same memories, concepts, goals, beliefs, and connection strengths. This creates a controlled experiment in which the starting state remains constant.
Only one variable changes: experience.
CORTEX-01A attempts an ambitious project, fails, and receives support from a mentor who helps turn each mistake into useful information. This strengthens associations between failure, feedback, learning, and opportunity.
CORTEX-01B attempts the same kind of project and also fails, but the failure happens publicly and leads to humiliation. This strengthens associations between failure, shame, social threat, and danger.
After those experiences are encoded, both minds receive exactly the same question:
Should I attempt an ambitious project when success is uncertain?
Although the two minds started identically, they now reach different decisions.
CORTEX-01A recommends attempting the project because it has learned to associate uncertainty with feedback and growth. CORTEX-01B recommends reducing uncertainty before acting because it has learned to associate failure with social danger.
MindAssembly does not stop at showing two different answers. It reveals the developmental path behind each one:
Experience → Association Update → Belief → Decision
For CORTEX-01A, the visible pathway becomes:
Supported Failure → Failure as Feedback → Uncertainty as Opportunity → Attempt
For CORTEX-01B, it becomes:
Public Humiliation → Failure as Threat → Uncertainty as Danger → Avoid
The application also calculates a Divergence Index: a single measure of how far the two minds have developed apart after receiving different experiences. The comparison considers changes in their cognitive connections, belief strengths, response meanings, and final decisions.
The complete interactive workflow has four stages:
- Initialize an original synthetic mind.
- Fork it into two identical cognitive states.
- Encode a different experience into each copy.
- Compare the resulting beliefs, decisions, and provenance paths.
The result is not simply a pair of different chatbot responses. It is a controlled demonstration of how one experiential variable can reshape an artificial cognitive structure.
MindAssembly is designed for AI education and responsible AI. Students can use it to understand how learning systems change through data and experience. Developers can use the underlying method to examine how personalized agents gradually acquire tendencies or biases. Researchers can use counterfactual mind forking as a framework for comparing artificial cognitive development.
How I built it
I built MindAssembly as an interactive web application using Next.js, React, TypeScript, and custom responsive CSS. It is deployed on Vercel, and the complete source code is publicly available on GitHub.
The prototype models a mind as a weighted cognitive graph:
Mind = Nodes + Connections + Connection Strengths
More formally:
G = (V, E, W)
Where:
Vis the set of cognitive nodes, including memories, concepts, beliefs, goals, and emotional signals.Eis the set of associations between those nodes.Wcontains the strength of each association.
An experience is not stored as a single block of text. It is treated as a structured cognitive event containing:
- Activated concepts
- Emotional context
- Causal interpretation
- Uncertainty
- Salience
When two cognitive nodes are activated by the same experience, their connection can become stronger. MindAssembly models this with a salience-weighted associative learning rule:
new connection strength =
(retention × current strength)
+ (learning rate × activation of node i × activation of node j × experience salience)
In compact form:
wᵢⱼ(t+1) = λwᵢⱼ(t) + ηaᵢaⱼs
Where:
wᵢⱼ(t)is the existing connection strength between nodes i and j.λis the retention or decay factor.ηis the learning rate.aᵢandaⱼare the activation strengths of the connected nodes.sis the salience of the experience.
This structure is inspired by associative learning and Hebbian-style updates: concepts that repeatedly activate together become more strongly connected, while unsupported pathways can weaken over time.
Repeated pathways can then be consolidated into beliefs. A belief is not stored as an isolated sentence. It is represented as a stable pattern supported by memories, concepts, emotions, and causal associations.
For example, the supportive experience strengthens this pathway:
Failure → Feedback → Learning
The humiliating experience strengthens a different pathway:
Failure → Shame → Threat
When a question is asked, the decision layer activates the strongest relevant pathways. The system produces an outcome and displays the cognitive provenance that led to it.
The Divergence Index is designed as a weighted combination of four differences:
Divergence =
α(graph difference)
+ β(belief difference)
+ γ(response difference)
+ δ(decision difference)
These components compare:
- Changes in cognitive graph structure
- Differences in belief strengths
- Semantic distance between responses
- Disagreement between final actions
The current prototype uses deterministic experiences and outcomes. This is an intentional design decision. A controlled experiment needs to be reproducible: judges and users should be able to repeat the demonstration, inspect every update, and verify the same causal pathway instead of receiving a different generated answer on every run.
The architecture is designed for future language model integration. In that version, an LLM would convert unstructured experiences into structured concepts, emotions, causal relationships, uncertainty values, and salience estimates. The cognitive graph would remain responsible for persistent structure, belief development, and provenance.
The responsibilities would remain separated:
Language model → Interprets an experience
Cognitive graph → Preserves persistent structure
Learning rules → Update the mind over time
Provenance system → Explains why the mind changed
This prevents the project from being reduced to prompting a language model and saving its conversation history.
I designed the interface as a luminous intelligence laboratory because the project needed to make an abstract cognitive system feel observable. The four-stage experiment, contrasting mind colors, evolving states, and visible provenance paths let users understand the central idea without first studying graph theory or machine learning.
Challenges I ran into
The largest challenge was defining the difference between a memory system and a mind.
An early version of the idea focused heavily on storing experiences and connecting knowledge. However, that direction was too similar to note-taking systems, vector databases, and existing AI memory products. A database can store thousands of memories without demonstrating development.
The project needed to show that an experience caused structural change.
The controlled mind-forking experiment solved this problem. By creating two identical minds and changing only one experiential variable, MindAssembly can demonstrate a causal relationship between experience, belief formation, and decision-making.
Another challenge was making an abstract architecture understandable within a short hackathon demonstration. Cognitive graphs, associative learning, belief consolidation, and counterfactual experiments can quickly become too theoretical. A technically ambitious system still fails as a product if users cannot immediately understand what it does.
I reduced the interaction to one clear narrative:
Start with one mind.
Create two identical copies.
Give each copy a different life.
Ask both the same question.
Trace why they disagree.
The Divergence Index gives users one visible measurement of change, while the experience-to-belief-to-decision pathway makes each result explainable.
A further challenge was balancing ambition with scientific honesty. Terms such as “synthetic mind†can easily create exaggerated expectations. MindAssembly does not claim consciousness, sentience, or biological equivalence. It is a computational experiment that models selected cognitive processes.
I also had to distinguish clearly between implemented functionality and future architecture. Live LLM experience encoding would make the system more flexible, but adding nondeterministic generation too early could weaken reproducibility and obscure the learning mechanism. The deterministic prototype therefore focuses on demonstrating its core idea transparently.
Finally, the visual design needed to feel futuristic without sacrificing clarity. Every animation, color, and state change had to support the experiment rather than distract from it.
Accomplishments that I'm proud of
I am most proud of turning an abstract philosophical question into a complete interactive experiment.
MindAssembly is not only a landing page describing a future product. Users can perform the entire central workflow:
- Initialize CORTEX-01.
- Fork it into two identical minds.
- Encode contrasting experiences.
- Observe changes in associations and beliefs.
- Ask both minds the same question.
- Compare their decisions.
- Switch between both cognitive outcomes.
- Inspect the provenance behind each response.
- Review the final Divergence Index.
I am also proud that the project has a distinct identity. MindAssembly is not positioned as another chatbot, note-taking application, “second brain,†or vector database. Its central contribution is the controlled study of artificial cognitive development.
The Divergence Index introduces an approach to personalized AI evaluation that goes beyond measuring the accuracy of a single output. It asks how far two initially identical systems can develop apart after receiving different histories.
The provenance paths extend explainability beyond the immediate response. Many explainable AI tools ask:
Why did the system produce this decision?
MindAssembly asks a deeper question:
What experiences made the system become the kind of system that would produce this decision?
I am proud that the final project combines technical implementation, conceptual innovation, responsible AI relevance, and a polished user experience. It works across desktop and mobile layouts, provides a clear four-stage interaction, and exposes its central algorithm instead of hiding it behind marketing language.
The project is publicly available and reproducible:
- Live application: mindassembly-ai.vercel.app
- Source code: github.com/shannon-aurelia/mindassembly-ai
What I learned
The most important lesson was that persistent AI requires more than a large context window.
A system does not become a mind simply because it stores more text. Persistent artificial cognition needs several separate components:
- A way to interpret experiences
- A structure for connecting memories and concepts
- Learning rules that determine what strengthens or decays
- A mechanism for consolidating repeated patterns into beliefs
- A decision process influenced by those beliefs
- A provenance layer that explains how development occurred
Separating these components produces a more transparent architecture than treating an LLM as the entire system.
I also learned that counterfactual copies can become a valuable auditing method. If two identical systems receive different experiences, developers can measure how each experience affects confidence, caution, bias, exploration, and decision-making.
This may become especially important for personalized AI. Two assistants using the same base model could eventually behave very differently because they interacted with different users, received different feedback, or observed different data. Counterfactual testing could help identify harmful behavioral drift before deployment.
Another lesson was that explainability should not stop at the current output. Traditional explanations often answer why a system produced one decision. Responsible personalized AI should also explain which experiences changed the system’s beliefs and how those changes made the decision more likely.
The project also reinforced the value of reproducibility. Deterministic behavior may initially look less flexible than unrestricted generation, but it creates a stronger scientific demonstration. Every user can repeat the experiment and inspect the same causal updates.
Finally, I learned that technical communication is part of technical implementation. An ambitious algorithm has limited impact if users cannot understand it. Visual hierarchy, interaction design, narrative order, and documentation were essential to making the cognitive model meaningful.
What's next for Mind Assembly
The next stage is to transform MindAssembly from a controlled prototype into a flexible experimentation platform.
The first major addition will be live experience encoding. Users will be able to describe their own experiences in natural language. A language model will identify relevant concepts, emotions, causal relationships, uncertainty, and salience before converting the experience into structured graph updates.
The language model will not become the long-term memory itself. Its role will remain interpretation, while the cognitive graph preserves persistent structure and provenance.
Future versions will include:
- User-created base minds with editable starting beliefs and values
- Multiple experiences distributed across a developmental timeline
- Interactive cognitive graphs that users can inspect and modify
- Belief consolidation after repeated supporting experiences
- Contradiction detection when new evidence conflicts with existing beliefs
- Memory decay for associations that are no longer reinforced
- Alternative learning rules for comparing cognitive architectures
- Saved mind states that can be forked at any point
- Experiments with more than two counterfactual minds
- Exportable reports explaining significant belief updates
- Quantitative comparisons across graphs, beliefs, responses, and decisions
- Classroom activities for teaching AI literacy and algorithmic bias
- Research tools for studying behavioral drift in personalized agents
A classroom mode could allow students to create controlled experiments without entering personal information. Students could investigate how supportive versus punitive feedback changes risk tolerance, how repeated misinformation affects belief strength, or how contradictory evidence should revise an artificial world model.
A responsible AI mode could help developers test personalization systems before deployment. Teams could fork identical agents, expose them to different histories, and identify which experiences produce undesirable biases or unsafe behavioral changes.
The long-term vision is for MindAssembly to become a transparent laboratory for computational development: a place where people can build artificial cognitive structures, expose them to experience, measure how they change, and understand why they eventually make different decisions.
The goal is not to create a system that remembers everything.
The goal is to create a system whose changes can be seen, questioned, and understood.
Built With
- explainable-ai
- graph-algorithms
- machine-learning
- next.js
- react
- responsible-ai
- typescript
- vercel
Log in or sign up for Devpost to join the conversation.