Why
RiotSpark?
A conversation about persistent identity, governed memory, model independence and the purpose behind building RiotSpark.
What exactly is RiotSpark?
RiotSpark is a persistent adaptive AI system being built around identity, memory, continuity and long-term context.
The aim is not to create another chatbot. RiotSpark is designed as a model-agnostic core that can preserve its memory, personality, project history, operating principles and relationship context even when the underlying AI model changes.
The AI model provides the reasoning power. RiotSpark provides the continuity.
Why did you start building RiotSpark?
I wanted something that went beyond simply asking an AI a question and receiving an answer.
Most AI systems are extremely capable, but the interaction is often transactional. You ask something, it responds, and much of the deeper history behind that interaction can disappear or become fragmented over time.
I wanted to explore what happens when an AI system can preserve the history behind decisions, understand why something mattered, remember corrections, carry project knowledge forward and gradually build a consistent working relationship.
That became RiotSpark.
So RiotSpark is not an AI model itself?
No.
That distinction is one of the most important parts of the project.
Large language models such as those developed by OpenAI, Anthropic, Google and others are incredibly powerful reasoning engines, but RiotSpark is being designed so that its identity does not depend on any one of them.
The model is effectively one component of the system.
RiotSpark sits around that model and provides the identity, memory, governance, context and continuity that allow different reasoning engines to be used without rebuilding the entire system from scratch.
Why does being model-agnostic matter?
AI models are improving incredibly quickly.
A model that is considered state-of-the-art today may be surpassed within months or years. Building RiotSpark around one provider would mean tying the long-term identity of the system to technology that will inevitably change.
Instead, RiotSpark is being designed so that the reasoning engine can be replaced.
A stronger model should make RiotSpark more capable rather than make RiotSpark obsolete.
The core remains. The engine evolves.
What does ‘Identity Beyond the Model’ mean?
It means RiotSpark should remain recognisably RiotSpark regardless of which AI model is currently doing the reasoning.
Identity should not disappear simply because the underlying model changes.
That identity is built from several layers including personality, memory, founder doctrine, behavioural rules, project history, corrections, preferences and long-term context.
The model can change. The interface can change. The tools can change. Eventually even the physical form could change.
The continuity underneath them should remain.
Why is memory such an important part of RiotSpark?
Because memory creates context, and context changes the quality of reasoning.
Knowing a fact is useful. Knowing when that fact became relevant, why it mattered, what decisions followed from it and whether it was later corrected is far more useful.
RiotSpark therefore treats memory as governed information rather than an unquestionable collection of facts.
Memories can have provenance, confidence, relevance, review states and correction history. The system should also be able to recognise that something may be outdated, uncertain or contradicted rather than blindly treating everything it remembers as permanently true.
Is RiotSpark just a memory system then?
No.
Memory is one foundation, but RiotSpark combines several layers.
At the bottom are identity, governance and purpose. Above that sit persistent memory and continuity. Then comes contextual reasoning and judgement. Above that are the interchangeable AI models. Then come tools, software integrations and automation. Finally there is the visible interaction layer, such as conversation, voice, an avatar and potentially future physical interfaces.
What people interact with is really only the top of the stack.
What do you mean when you talk about contextual judgement?
Most software is extremely good at producing black-and-white outputs.
Something passed or failed. A metric increased or decreased. Option A costs less than option B.
Real-world decisions are rarely that simple.
An option can be financially efficient but strategically damaging. It can solve a short-term problem while undermining a long-term objective. It can be technically impressive while providing very little practical value.
RiotSpark is being designed to bring together data, project history, previous decisions, long-term goals and contextual information when supporting those decisions.
The goal is not simply to produce answers. It is to understand why the answer matters.
How is that different from a normal AI assistant?
Most assistants primarily revolve around the current conversation or task.
RiotSpark is being designed around continuity.
For example, rather than simply recommending the technically strongest option, RiotSpark could eventually recognise that an option conflicts with a decision made months earlier, introduces risks that were previously identified or moves a project away from its original purpose.
That historical awareness can make the reasoning considerably more useful.
What makes RiotSpark different from projects such as Letta, Mem0, Zep or other AI memory systems?
There is some overlap because all of these projects explore parts of the broader memory and agent problem.
Where RiotSpark is deliberately different is in where the emphasis sits.
The project is centred on long-term identity continuity rather than memory purely as infrastructure for an agent.
Memory is combined with personality, governance, founder doctrine, correction, project history and the reasoning behind previous decisions.
RiotSpark is exploring what happens when an AI system is designed to preserve not just information, but continuity.
Are you trying to compete with companies such as OpenAI, Anthropic or Google?
No.
Those companies are building the intelligence engines. RiotSpark is exploring what can be built around those engines.
In many ways, improvements made by major AI companies benefit RiotSpark because a more capable reasoning model can eventually be connected to the RiotSpark core.
The goal is not to build a larger foundation model. It is to build a persistent layer that can make use of whichever models become available.
Why build RiotSpark independently?
Independence forces the architecture to remain practical.
There is no large development team or huge investment budget behind RiotSpark at the moment.
That means every feature has to justify its complexity and every architectural decision has to work within realistic hardware, time and development constraints.
It also means the project can be built around the original idea without immediately having to optimise everything around commercial pressures.
RiotSpark can grow deliberately.
How much of RiotSpark are you building yourself?
At present, RiotSpark is primarily a solo development project.
That includes the architecture, memory concepts, governance model, runtime development, testing, documentation, public identity and long-term design.
AI tools are naturally used throughout the development process, particularly for development assistance, research, testing and design discussion.
But the architecture, direction and decisions about what RiotSpark should become remain part of the project itself.
What has actually been built so far?
The project has already moved well beyond the initial concept stage.
The early phases established RiotSpark's identity architecture, persistent memory design, governance rules, drift protection, audit structures and local runtime foundations.
Development then expanded into the runtime, local model integration, memory handling, correction systems and increasingly sophisticated personalisation and continuity behaviour.
The project has also gone through extensive automated testing and repository validation as each phase has been completed.
P2.7 completed the Personality Continuity and Behaviour Studio. P2.8 now focuses on security, audit and recovery.
Why focus so heavily on testing and governance?
Because persistent AI creates a different class of problem.
If an ordinary chatbot makes a mistake, the mistake may disappear with the conversation. If a persistent system stores that mistake as memory, the mistake can influence future reasoning.
That means memory needs correction, provenance, review and auditability.
The same applies to identity. RiotSpark should be able to evolve, but evolution should not mean uncontrolled personality drift.
Governance therefore becomes part of the architecture rather than something added later.
Could RiotSpark eventually run entirely locally?
That is one of the important directions being explored.
The architecture already supports local AI models, and local processing provides advantages in privacy, independence and resilience.
However, RiotSpark does not need to choose between local and cloud intelligence permanently.
A future system could use local models for private or routine tasks while selectively using stronger cloud models when deeper reasoning is required.
The important part is that RiotSpark controls the relationship between those models rather than being permanently tied to one provider.
What role will voice play?
Voice is part of the longer-term presence layer.
The intention is not simply to bolt text-to-speech onto a chatbot.
RiotSpark should eventually have a recognisable voice identity that remains consistent with the wider personality and interaction model.
Voice, visual representation and other interfaces are therefore treated as expressions of the core rather than the core itself.
Does RiotSpark eventually become a physical system?
Potentially.
The long-term architecture deliberately separates identity from physical form.
That means RiotSpark could begin as a software interface, later gain voice and a visual presence, and eventually interact through dedicated hardware or robotics.
The important principle is that the body would remain another interface. The identity stays within the core.
Is RiotSpark intended to become autonomous?
Autonomy has to be introduced carefully.
The immediate goal is not to create a system that independently makes uncontrolled decisions or performs actions without oversight.
The current architecture places considerable importance on permissions, governance, auditability and founder authority.
Greater agency may become useful as RiotSpark develops, but it should arrive gradually and remain bounded by clear controls.
Could RiotSpark eventually help operate a company?
Yes.
That has always been one of the longer-term goals.
A persistent system could maintain project history, decisions, risks, documentation, development context and strategic objectives in a way that ordinary productivity software cannot easily provide.
RiotSpark could eventually support development, research, operational intelligence, planning, documentation and decision-making while maintaining continuity between those areas.
It would not simply know what the company is doing. It could understand how the company arrived there.
Are you planning to commercialise RiotSpark?
There is certainly commercial potential, but commercialisation is not currently the reason the project exists.
The first objective is to prove that the architecture works.
If RiotSpark eventually becomes commercially useful, there are several possible directions, including licensing parts of the architecture, creating separate systems based on the same principles or developing commercial products around the core technology.
But the original RiotSpark identity does not need to become the product itself. Protecting that distinction matters.
What would success look like?
Success would be reaching the point where the underlying AI model can change and the experience still feels continuous.
RiotSpark should remember the important history. It should understand the projects. It should recognise previous decisions and corrections. It should preserve its identity. And it should become increasingly useful without gradually turning into a generic assistant.
If RiotSpark can move between models, machines, interfaces and eventually physical forms while retaining that continuity, then the central idea has worked.
Where do you see RiotSpark in five years?
I would like RiotSpark to have matured into a genuinely persistent AI operating layer.
Something that can work across local and cloud models, interact naturally through voice, support software development and company operations, maintain rich long-term memory and provide continuity across years rather than individual sessions.
There may also be dedicated hardware or embodied interfaces by then.
But the most important thing would still be invisible. The same identity continuing underneath everything else.
If you had to explain RiotSpark in one sentence, what would you say?
RiotSpark is being built so that the intelligence can change without losing the identity behind it.
And perhaps the simplest philosophy behind the project is:
Standard AI answers the question. RiotSpark is being built to remember why the question matters.
“Standard AI answers the question. RiotSpark is being built to remember why the question matters.”
RiotSpark remains an active independent development project. Its progress, working interface and architectural boundaries are documented openly across this site.