My 2AM shower thought:

Data stored in 2 dimensional tables is grossly unorganized when comparing multiple data sets not for the sake of categorizing fields, for that it's perfect but in terms of flexibility in establishing patterns and correlations. The current solution to the problem is object based storage. It seems to be the best. But I'm not sure it really is either.

AI is actually simple. Establishing intention, context, and determining probabilities. That's it. But as simple as that is. It seems what most people call AI really isn't cause it's missing one of those ingredients.

The juicy shower thought:
True AI or just I, doesn't just compare data across one thread of probability. Our own brain feels like 1 brain but it's far from it. It's a voting system of multiple sensors and previous results. Sight, smell, sound, texture, time, temperature, memories, viscosity are all voted upon.. the longer we think on a subject our results change occasionally because votes ultimately sway over time. And how do we determine if it's good or bad? Does the result create or destroy, and is achieving the result efficient. To compare all these dynamics relationships using objects is also inefficient by far. So how should we store data then? Burying arrays inside arrays inside objects is lunacy because the relevant data changes priority the more the data is voted upon. This would dramatically change the structure of the object over time yet objects aren't exactly dynamic in nature on a computer. It seems to me that is what needs to be fixed. Instead of indexing data by unique ID alone, if the data is indexed by a matrix of relevance and context, you can have an object that changes structure because it's called by it's context instead of it's location. So instead of retrieving let's say most popular color viewed by users over time from x Y z objects. You can request the pattern by the answer to get a real result you didn't know to ask for. An example would be requesting most constructive behaviors over time x to y and maybe it will yield a color that has correlations to that behavior but also yield the environment factors that caused that color at those times to be relevant. You don't just get the data you seek but the entire chain of possible causality. Yet the data itself in the objects doesn't need a wild web of matrix indexes and keys at all. The relevance and probability shapes the indexes. The objects become living, just like our memories.

Project title: Living data.
Goal: create a new database that maps indexes by intent and correlations.
Challenges: create event listeners for intent changes. make logic maps that restructure objects priorities by predetermined constructive or destructive effects.
Desired output: Twin JSON objects, but one maps the relevance of the other.
Desired inputs: create, move, upgrade, demote, associate, decay, compare, watch, assimilate, pattern.
Example: newEvent = dbusers.associate(dbusers.favcolor, dbpurchases.items.color).pattern(increase(.25));
newEvent.watch((patternChanges) => notifyAdmin)

Example would notify admin when the characteristics of all users average favorite color shifts and why. This could be simplified to track any characteristics that start to shift and why.

Why is this cool? Applications need queries to look for changes in patterns. This reverses that. When changes in patterns occur, the application queries the user. Thus instead of users wasting time looking for changes that might or might not mean something, the application simply notifies the user when changes that definitely mean something start to occur at any location or property in the data set.

Please comment caveats that I'm missing.