This project started with a deceptively simple question:
Given everything ChatGPT had learned about me through our conversations over the past year or two, could it describe my personality accurately?
I asked it for a personality profile based on the way I think, communicate, solve problems, make decisions, build products, lead teams, and react when something does not make sense.
The resulting profile was more detailed than I expected.
It identified recurring patterns in how I approach problems: strong systems thinking, curiosity, skepticism, a tendency to look for the mechanism behind things, a preference for evidence over vague claims, and an almost automatic instinct to ask:
“What am I missing?”
It also identified some less flattering patterns.
- A tendency to overbuild.
- To chase completeness.
- To switch contexts aggressively.
- And occasionally to continue solving a problem long after an acceptable answer already exists.
Fair enough.
So I pushed the experiment further.
What Would a Psychological Assessment Look Like?
My next question was:
Based on everything you know about me, what would a psychological-style assessment look like?
This was never intended as a clinical diagnosis.
The goal was to look at recurring behavioural tendencies: how I respond to uncertainty, how I process problems, how I balance empathy with accountability, how much control I want over systems I depend on, and how strongly curiosity, productivity, and problem-solving appear to influence my behaviour.
Again, the result felt surprisingly recognizable.
Not perfect.
Not magical.
But recognizable enough that another question emerged almost immediately.
Could an AI build a reasonably accurate simulation of me?
That is where this project really began.
Not a Chatbot That Knows Facts About Me
The obvious interpretation would be to build a chatbot containing biographical information.
- My career history.
- Projects.
- Preferences.
- Writing style.
- Things I like.
- Things I dislike.
That is not what interests me.
A system that knows facts about me is just a personalized database with a conversational interface.
The more interesting challenge is whether a system can model enough of my decision-making patterns, biases, contradictions, communication style, and reasoning habits that it can respond to a new situation roughly the way I would.
Not simply: “What does Mo know?”
But: “What would Mo probably think?”
- Would it ask the same questions?
- Challenge the same assumptions?
- Notice the same risks?
- Get distracted by the same interesting technical possibility?
- Decide to prototype something when perhaps it should simply leave it alone?
That became the idea behind MoSim.
Then I Realized This Is Not Such a Strange Idea
At first, the concept felt slightly eccentric.
Then I started looking at where AI is heading.
OpenAI CEO Sam Altman has publicly described a future in which AI becomes deeply personal.
At Sequoia Capital’s AI Ascent in 2025, Altman described what he called a “core AI subscription” for your life: an AI system capable of remembering the context of your life across conversations, email, and other services. The vision is essentially an intelligence layer that becomes progressively more useful because it accumulates an extraordinary amount of context about one individual.
That is already a profound change from how most software works.
Traditional software waits for instructions.
A deeply personalized AI begins to understand context.
- Preferences.
- History.
- Patterns.
Eventually perhaps even things you have never explicitly told it, but which can be inferred from repeated behaviour.
Altman’s vision is primarily about building an AI that understands you well enough to become an extraordinarily capable assistant.
But it raises a different question.
If an AI knows enough about me to anticipate what information I need, could that same information allow it to anticipate how I would think?
That is the fork in the road where MoSim begins.
Personal AI vs. Behavioural Simulation
There is an important distinction here.
A personal AI asks: “Given everything I know about Mo, how can I help him?”
MoSim asks: “Given everything I know about Mo, what would Mo probably do?”
Those are not the same problem.
One optimizes assistance.
The other attempts behavioural prediction.
And it turns out researchers have already demonstrated that this idea is not purely theoretical.
Researchers Have Already Tried This With More Than 1,000 People
In 2024, researchers from Stanford University and collaborating institutions published a study called Generative Agent Simulations of 1,000 People.
They recruited 1,052 real people and conducted approximately two-hour qualitative interviews with each participant.
Those interviews were then combined with large language models to create individual generative agents intended to simulate the attitudes and behaviour of the actual participants.
The researchers then tested both the humans and their simulated counterparts using surveys, personality measures, and behavioural experiments.
One result immediately stood out to me.
The agents reproduced participants’ responses on the General Social Survey 85% as accurately as the participants reproduced their own answers when retested two weeks later.
That is not the same thing as creating a complete digital human.
The researchers themselves are careful about that distinction.
But it demonstrates something important:
A relatively small amount of carefully captured personal information can produce measurable predictive behaviour.
That makes the MoSim experiment considerably more interesting.
My Dataset Was Created Accidentally
The Stanford experiment started with a deliberate two-hour interview.
My situation is different.
I never sat down and attempted to teach an AI who I am.
Instead, a large body of behavioural information accumulated naturally through ordinary conversations.
Over a long period of time I have used AI while working through real decisions, technical problems, product ideas, leadership questions, writing, strategy, design, marketing, software architecture, troubleshooting, disagreements, successes, failures, and plenty of occasions where I changed my mind after receiving better information.
That distinction matters.
A structured interview captures what someone says about themselves.
Long-term interaction also captures what someone does repeatedly.
- The questions they ask.
- The objections they raise.
- What annoys them.
- What excites them.
- How quickly they make decisions.
- When they change direction.
- What evidence convinces them.
- What they consistently overlook.
That may be an extremely valuable behavioural dataset precisely because it was not created as one.
Someone Has Already Tried Meeting Their AI Self
In 2025, Scientific American journalist Webb Wright participated in essentially the same Stanford process.
He spent almost two hours telling an AI interviewer about his life. The resulting information was used to create a generative agent intended to reproduce aspects of his personality and beliefs.
His experience is especially useful because it highlights both the promise and the limitations.
The agent could infer some surprisingly accurate things about him.
At other times, it fabricated plausible-sounding details that had never happened.
And although some responses felt strikingly familiar, Wright ultimately described the system as capturing only a limited representation of him rather than some complete digital self.
That limitation is important.
I do not want MoSim to become an exercise in convincing myself that an LLM contains my consciousness.
It does not.
The goal is much narrower.
Can we construct a useful behavioural approximation?
The Idea Is Already Moving Into the Business World
This concept is also beginning to appear outside academic research.
In 2026, Axios wrote about executives constructing AI-powered versions of themselves by feeding models speeches, memos, articles, and other material.
These personalized agents were not merely being used to write in the executive’s style.
They were being used to challenge decisions, run premortems, surface hypotheses, and provide an alternative perspective modeled from that person’s existing thinking.
That gets much closer to what interests me.
The useful version of a simulated person is not one that writes a convincing email in their voice.
It is one that can help reproduce their judgment.
So What Exactly Is MoSim?
MoSim is an experiment in building what I would currently describe as a:
Personal Cognitive-Behavioural Simulation
The goal is not to reproduce consciousness.
It is not to create a digital soul.
And it is certainly not to upload myself into a computer.
The goal is to determine whether a locally controlled AI system can model enough of my recurring behavioural patterns that it can make reasonably accurate predictions about how I would approach unfamiliar situations.
Given a problem I have never encountered before, can it predict:
- what questions I would ask;
- what assumptions I would challenge;
- what risks I would notice;
- what tradeoffs I would care about;
- what decision I would probably make;
- and where my own predictable biases might influence that decision?
That last part may eventually be the most useful.
A simulation of yourself could potentially become a kind of cognitive mirror.
Instead of asking: “What should I do?”
I could ask: “What would I normally do?”
And then: “Where might my normal way of thinking be hurting me here?”
That is a much more interesting tool.
Privacy Is a Core Requirement
There is one obvious problem with creating an increasingly detailed behavioural model of yourself. You are creating an increasingly detailed behavioural model of yourself.
I am not particularly interested in building a giant external Mo database somewhere. That feels like enough Mo for everyone.
So the first implementation of MoSim will run locally.
The personality model, behavioural parameters, memory, correction history, and conversation records will remain on hardware I control.
The initial system will use a locally running language model rather than sending that material to an external AI provider.
This introduces tradeoffs.
A local model may not reason as well as the strongest cloud systems.
It may struggle more with subtle personality consistency.
It may require experimentation with model size, memory retrieval, prompting, and hardware.
That is fine.
This is an experiment.
The Initial Tech Stack
The first version of MoSim does not need an elaborate architecture.
In fact, one of the goals is to keep the system deliberately small enough that I can understand every moving part.
The initial stack will likely look something like this:
Local Language Model
The core model will run locally using a tool such as Ollama or LM Studio.
That gives me a simple way to test different open models without sending the underlying personality data, conversation history, or behavioural model to an external API.
Candidates will likely include models from families such as:
- Llama
- Qwen
- Gemma
- Mistral
The exact model is less important at the beginning than establishing whether a local model can maintain the behavioural consistency I am looking for.
If one model performs poorly, I should be able to swap it out without rebuilding MoSim.
Local Application
The user interface can be extremely simple.
At first, MoSim only needs:
- a chat window;
- conversation history;
- a way to load the behavioural model;
- memory retrieval;
- and a mechanism for correcting the simulation when it gets me wrong.
There is only one intended user.
Me.
So there is no need for multi-user architecture, account management, complex authentication, or cloud infrastructure.
A lightweight local web application running on localhost is probably sufficient.
Application Layer
The application itself could be built with something equally uncomplicated.
Likely options are:
Node.js + SQLite
or
PHP + SQLite
The important thing is not the language.
The application layer has a relatively simple job:
- receive my message;
- retrieve relevant memories;
- load the behavioural profile;
- assemble the prompt;
- send that context to the local LLM;
- return the response;
- store the conversation and any corrections.
The AI model generates the language.
MoSim provides the identity and context.
SQLite for Memory
For the first version, a traditional database is probably enough.
I do not want to introduce a vector database simply because AI projects are apparently required by law to contain one.
SQLite can initially hold things such as:
- personality traits;
- behavioural weights;
- known preferences;
- recurring decision patterns;
- memories;
- conversations;
- simulation corrections;
- confidence levels.
If semantic retrieval eventually becomes necessary, embeddings and vector search can be added later.
But they should solve an actual problem before becoming part of the architecture.
The Behavioural Model
This is likely the most important part of the entire system.
Rather than putting everything into one enormous system prompt, MoSim will maintain a structured behavioural profile.
That might contain values such as:
systems_thinking 0.94
curiosity 0.91
skepticism 0.83
need_for_evidence 0.81
directness 0.79
implementation_bias 0.77
novelty_seeking 0.72
perfectionism 0.68
risk_tolerance 0.58Those numbers are not intended to mathematically determine what I will do.
They are signals.
The model will also contain contextual modifiers.
For example, I may behave differently when evaluating a business investment than when experimenting with a new technology.
That means the simulation should represent not just traits, but how those traits shift depending on the situation.
Memory Retrieval
MoSim should not receive everything it knows about me with every message.
Humans do not consciously load their entire autobiography before answering a question either.
Instead, the application will retrieve only the memories and behavioural information relevant to the current conversation.
A product question might retrieve previous product decisions.
A leadership question might retrieve examples of how I have handled team performance and accountability.
A technical question might activate stronger curiosity and experimentation tendencies.
The challenge will be deciding what context is relevant without overwhelming the model.
Personal Data Access Will Be Explicit, Not Assumed
One important design principle is that MoSim will not begin with access to my email, calendar, documents, messages, browser history, cloud storage, or other personal information.
The initial system will be intentionally constrained.
Its knowledge of me will come from the behavioural model, selected conversation history, memories I deliberately provide, and corrections gathered during testing.
That boundary matters.
A system designed to simulate an individual could easily drift from:
“model how I tend to think”
into:
“ingest everything I have ever done.”
Those are very different projects.
At least initially, MoSim does not need my inbox to understand whether I tend to challenge assumptions, look for measurable outcomes, or overcomplicate interesting problems.
If additional personal context later proves genuinely useful, access could be added selectively.
For example, I might eventually decide that allowing MoSim to read certain email threads, calendar history, documents, project notes, or other personal records would improve its ability to reconstruct past decisions or understand how I behaved in real situations.
But that access would follow a few rules:
- it would be opt-in;
- access would be granted to specific sources deliberately;
- the reason for adding a source should be clear;
- data should remain local wherever technically possible;
- the system should store only what is necessary;
- access should be removable;
- and MoSim should never silently expand what it can see.
In other words:
More data is not automatically better data.
The question should always be:
Does giving MoSim access to this information materially improve the simulation?
If the answer is no, it should not have access.
If the answer eventually becomes yes, then that becomes another experiment to test rather than an assumption baked into the architecture from day one.
That also gives us a useful progression for the project:
Stage 1: behavioural profile and conversation-derived memory
Stage 2: corrections and controlled personal memories
Stage 3: optional access to selected personal data sources
Stage 4: measure whether the additional context actually improves behavioural prediction
The interesting result may ultimately be that MoSim needs far less personal data than expected.
And from both a privacy and engineering perspective, that would probably be the better outcome.
Corrections as Training Data
One of the most important parts of MoSim will be what happens when it gets me wrong.
Suppose the simulation says:
“I would probably build that immediately.”
And my actual reaction is:
“No chance. I would validate demand first.”
That correction should be stored.
Over time those corrections become one of the most valuable datasets in the system because they capture the difference between:
what the model thinks I am like
and
what I actually say I would do.
That allows MoSim to improve without immediately resorting to model fine-tuning.
No Fine-Tuning, At Least Initially
Fine-tuning sounds attractive because it feels like the obvious way to create a personalized model.
I am deliberately avoiding it at the beginning.
The first version will use:
base model + behavioural profile + relevant memory + corrections + current context
That architecture is easier to inspect, easier to modify, and much easier to debug.
If the simulation behaves incorrectly, I want to be able to ask:
Was the wrong memory retrieved?
Was the behavioural weighting wrong?
Was the prompt poorly structured?
Or did the underlying model simply make a bad inference?
Fine-tuning can come later if there is evidence that it solves a specific limitation.
The Architecture in One Picture
Conceptually, MoSim v1 is fairly simple:
MoSim
│
▼
Local Chat Interface
│
▼
Context / Prompt Builder
↙ ↘
Behavioural Model Memory
↘ ↙
▼
Local LLM
│
▼
Mo Response
│
▼
Conversation + CorrectionsThe technology itself is not particularly exotic.
The interesting part is what sits in the middle:
the representation of the person.
That is where I expect most of the experimentation to happen.
Because if this project works, it probably will not be because I found the perfect database or the perfect local language model.
It will be because I found a sufficiently accurate way to represent how I tend to think.
The First Phase Is Not Coding
My natural inclination with an idea like this is to start building software. That is also precisely the sort of behavioural tendency MoSim should eventually learn about me.
But this time I am deliberately resisting it.
The first problem is not the user interface.
A chat window is easy.
The difficult part is determining what information actually represents a person well enough to be useful.
So the first phase will focus on modelling.
That will likely include:
- a structured personality specification;
- behavioural traits and confidence levels;
- decision-making patterns;
- known biases;
- contradictions;
- communication tendencies;
- contextual modifiers;
- memory;
- and a correction system that allows the simulation to improve when it gets me wrong.
Only after that model produces convincing behaviour does it make sense to wrap it in an application.
Then We Need to Test It
The most important part of this project may ultimately be testing.
A simulation that merely sounds like me is not particularly impressive.
Language models are already very good at imitation.
The harder test is whether it can predict me.
So one of the experiments I want to run is a blind comparison.
I will be given a collection of unfamiliar scenarios across areas such as leadership, product development, hiring, technology, business strategy, risk, customer operations, and decision-making.
I will answer them independently.
MoSim will answer the same scenarios without seeing my answers.
Then the two can be compared.
Not just for wording.
But for:
- decision similarity;
- reasoning path;
- questions raised;
- risk assessment;
- priorities;
- confidence;
- and final recommendation.
That will tell us whether the system has learned something meaningful. Or whether it has simply become very good at doing an impression of me.
The Experiment Begins With an Unusual Dataset
Me:
- My decisions.
- My contradictions.
- My habits.
- My biases.
- My way of thinking through problems.
- My tendency to question things.
- My tendency to build things.
And inevitably all the occasions where I take what should have been a small experiment and start designing the infrastructure for an entire platform.
Maybe MoSim will eventually tell me to stop doing that. Although, if it is an accurate simulation of me, I am not optimistic.
The larger question behind the project is simple:
How accurately can an AI learn to reason the way one specific person tends to reason, without pretending to actually be that person?
That is what I intend to find out.
About The Author
