This is cool. We’re clearly moving fast on the tooling layer.
What’s still unsolved is what happens after you have all this data.
Most systems can capture and connect,
but struggle to turn that into actually usable knowledge.
Especially when knowledge needs to be reused across contexts, not just retrieved.
See my own analysis on the past experiences: https://t.co/yBFQV9H0a2
@RenOther74832 Interesting angle.
I tend to think the more immediate issue isn’t consciousness, but usability.
most AI systems don’t fail because they lack awareness,
but because the knowledge they operate on isn’t structured in a way they can actually use.
Most “second brains” still fail at the same thing:
they store information, but don’t make it usable.
That’s where things usually break.
Been experimenting with this a lot recently.
The interesting part isn’t the setup, it’s what happens after.
Whether the knowledge actually becomes usable context or just sits there.
Wrote my own experiences: Why Most AI Agents Fail at Personal Knowledge (And how to actually fix it)
https://t.co/yBFQV9H0a2
Honestly, I wrote this because my OpenClaw agent started failing me. 📉
The agent wasn't the problem—my messy knowledge was. I built Thinkly to fix this exactly
Dump → Auto-structure → Knowledge Graph.
Stop fixing prompts. Start fixing your knowledge layer.
https://t.co/1XyMnJFqRk
This is the way. I’ve been preaching that Output = Agent × Context.
Most people blame the model, but the real bottleneck is almost always the knowledge structure.
I just broke down why these 'Second Brains' are the only way to fix broken agent reasoning, inspired by Karpathy's methods.
If you're building a system like this, you might find the 'Context Triggers' section in my thread useful:
https://t.co/yBFQV9H0a2
Graphify is a massive win for reducing token costs, but there’s a trap.
Automation without Intent is just organized chaos.
Building the graph is Step 1. Step 2 is turning those nodes into 'Actionable Insights' that a founder can actually use to make decisions.
I’ve been mapping out the 'Missing Layer' how to bridge the gap between Karpathy’s structure and Gary Tan’s persistence.
Here is the full blueprint on what comes after the graph:
https://t.co/yBFQV9H0a2
Locally running agents are a massive win for privacy, but here is the cold truth.
even the best agent is only as good as the knowledge you feed it.
As Andrej Karpathy pointed out, the real bottleneck isn't the tool.
It's how we structure our personal knowledge for LLMs to actually reason over it.
I’ve broken down the framework to fix this 'context gap' here:
https://t.co/yBFQV9H0a2
This is a great direction — and really well executed by https://t.co/tcnF6fqLdt.
Karpathy showed the idea, and it’s exciting to see it turning into real products.
But I think most people will stop at building a wiki.
And that’s where it usually breaks.
Because the real problem isn’t storing knowledge —
it’s making it usable in the moment.
Can it be retrieved, connected, and applied when it actually matters?
That’s the hard part.
That’s when it stops being a wiki
and starts behaving like a system.
Everyone is building agents.
Almost no one is fixing the knowledge layer.
That’s why these systems still feel incomplete.
https://t.co/yBFQV9H0a2
This is exactly what most people miss.
Karpathy showed the idea.
But actually building this system is still too complex for most people.
This is a really clean implementation ↓
Karpathy's LLM knowledge base system uses Obsidian, LLM agents, and custom scripts.
We built the same dump-and-compile workflow into one app. No setup.
Just paste, pick a template, publish.
That's Thinkly.
This is a big step.
But most people will miss the hard part
the knowledge itself still isn’t structured well enough to be usable.
Integrating it into agents is great.
But if the underlying knowledge is fragmented,
the output won’t improve much.
The real unlock isn’t the tool.
It’s turning that knowledge into a graph the agent can actually reason over.
Agents don’t fix bad knowledge.
They amplify it.
Most “second brain” systems break exactly here.
https://t.co/e0VJi1mdMK
This is interesting.
But the real shift isn’t token efficiency.
It’s moving from notes → knowledge systems.
70x token reduction is cool.
But if the knowledge isn’t structured,
you’re just retrieving noise faster.
Most people think graphs are about storage.
They’re not.
They’re about making knowledge usable.
Faster retrieval ≠ better thinking
This is why most “second brain” systems fail.
Broke it down here ↓
https://t.co/e0VJi1mdMK
This helps a lot with input.
But the bigger problem is what happens after the data is pulled in.
Most people still don’t have usable structure.
Tools are getting better at moving data.
But most systems still break at:
retrieval
context
reuse
The real unlock isn’t better pipelines.
It’s turning that data into a graph the AI can actually use.
Input is solved.
Structure isn’t.
Most people optimize input,
but their knowledge still isn’t usable.
Broke this down here ↓
https://t.co/e0VJi1mdMK