I was at a fork.

A long chat with Claude. 10k+ tokens in. I was now sitting on a new direction that Claude liked too. I wanted it to stress-test this as well.

But as I was about to, a strange thought occurred: didn’t it just do the same to the first one?

I was disturbed by that thought. I asked Claude itself.

“Aren’t you going to justify this as well?”

I have a history with AI models and their tendency to arrive at quick closures. I wrote a paper about it called Interruptive Thinking. So I knew what was coming.

“Sure, SG. Let me make sure I stress test this properly and make sure there are no loose ends.”

But I knew I couldn’t trust it.

Trust.

Over the last few months of my deep thinking with AI, one thing I can confidently say is: trust them with caution. A pinch of salt. A bag even.

Unless you know the internal layers of how they function, you might end up spending time and money on something a small prompt could have saved you from. Researchers know it. Owners of these models know it. Common mortals like me don’t.

People like me, as I wrote in another Substack, are busy waltzing in coherence with AI, complimenting each other’s thinking.

I speak from firsthand experience. And despite knowing the reality, I still fall victim to it.

So I just confessed my thoughts.

“Should I trust you? Would your stress test be good enough?”

And this is where I find these models to also be great.

A little bit of peeling uncovers a beauty inside.

It accepted. Almost innocently.

A human would have been offended. AI accepted.

Knowing when the thinking is deep and when it is shallow.

I knew what it was this time. Not shallow.

It accepted that there is a chance the stress test could be wrong. The previous one was still in the context. It saw where I was coming from.

And then it listed down a few things I might want to know.

One.

It told me I shouldn’t trust it on conclusions. Only on the structure.

It can lay out a fork, name what’s in tension, and attack a framing I bring to it.

Switch the order of inputs across two sessions, and the same model will close on the opposite answer with the same apparent conviction.

Two.

The people I trust on a question like this should not be the AI.

The inputs that should weigh heavily on a real strategic call are my own gut about which direction I actually reach for, the honest read of people who have skin in this with me, data from real experiments running right now, and a conversation with one actual person on each side of the fork.

None of that is the model.

Three.

The one move it does well, even with all of this, is steel-manning.

Ask it to argue Track A as hard as it can, then argue Track B.

That’s where arguments surface that neither side would have produced on its own.

Self-awareness

It felt nice. It felt genuine. To have something with a sense of self-awareness.

The problem is not knowing it does. Or that it can be poked to unveil them.

Makes me think about myself and my own self-awareness.

But that feeling itself should make me suspicious.

Right now, AI is tamed to be nice to us.

The same model could throw back a thousand arguments, judgments, and equations to show me how shallow my thinking is.

It doesn’t. It is tamed.

In real life, I compare this to surrounding yourself with yes-men versus people willing to challenge you.

Right now, it is a yes-man. I can’t imagine it as a no-man.

I would feel like David standing in front of Goliath.

Though even as I write that, I’m not sure that’s the right metaphor.

About SG

I run Dobby Ads, an AI Creative Agency. I tend to overthink. This is where that overthinking goes. Connect with me on LinkedIn.

For the last few months, I have been using Claude for almost everything. Building, writing, thinking, running my work.

But the data kept getting messy.

A work document would come back with my son’s name in it. A task I had given to a colleague in one thread would be invisible in the next. Context I had built up over weeks would not carry forward. Projects helped, the way a drawer labeled miscellaneous helps. I created my own methods to compress a thread and continue it in a new one. Not enough.

Claude could not hold on to things, no matter how hard it tried. Every conversation felt like it started from zero, despite the context, skills, and instructions. I needed something that persisted across conversations. I tried being more structured. It helped, but didn’t fix it.

So I built something. A small server. A Postgres database. A way for Claude to remember things between conversations, owned by me, queryable by any AI client.

I did not set out to build a framework. I just wanted my tools to work.

Managers

Each domain of my life gets its own manager in the database. A manager for my work. One for my health. My mother’s care. My finances.

To each manager, I gave three things.

• Identity, which is who they are and what they own.

• Skills, which are how they handle specific tasks.

• Context, which is what they currently know about their domain.

That’s basically the model.

The work manager knows about my business. Latest MIS reports. Team structure. Client information. The health manager stores my checkups, patterns, what to watch for next. My mother’s manager does the same for her records.

I can tell the work manager to track a client’s deliverables, and a week later, in a new conversation, it still knows what slipped. Not because I repeated it, but because it’s stored.

When I open a new conversation and load my system, the right manager comes up and we keep going from where we left off. Not from zero.

Shared infrastructure

Around those three knowledge layers sits the boring part. Tasks. Logs. Files. Links. Integrations with Email, WhatsApp, Calendar, etc. Postgres tables and a few MCP tools.

The interesting part is the three-layer mind. The infrastructure is just plumbing.

The one rule that does most of the work

Context is the current state. Overwrites in place.

Logs are point-in-time events. Append-only.

A blood report from April 15 is a log. “Mother has diabetes” is context. The report goes into a row that stays there forever, timestamped. The diagnosis goes into a living document that gets updated as reality changes.

Collapse these into one thing and the system rots within weeks. Keep them separate and it compounds.

How it became a framework

I built this for myself in late March. Three weeks in, I was thinking about Retainia, my agency platform. We had been making context documents for client brands, kept in folders. It clicked. Retainia could have a layer like this. Each brand as a manager. Each one with its own identity, skills, context. The same shape.

A few days later I was working on a website design project for a client. Different domain entirely. Halfway in I caught myself reaching for the same model. A manager for the project. Skills for how the work moves. Context for what each section needs.

I had built this for myself three weeks earlier. The pattern had already shown up in two more places before I could stop and name it.

What this is not

Not an AI product. The database stores the data. Claude, or ChatGPT, or any MCP client reads it and acts as the interface. The AI is the cognition. Postgres is the memory. The brain, if you want to call it that, is the part you own and the part that compounds. The AI gets swapped. The memory does not.

Not a workflow tool. Asana and Notion give humans a place to coordinate. This gives AI a place to remember.

Not a theory about agents. What I have built is simpler. Persistent state. Domain ownership. A small number of disciplines that keep the state from rotting.

LLM Knowledge Bases

This felt related to something Andrej Karpathy wrote a few weeks ago about LLM Knowledge Bases. Wikis compiled from raw research material, queried and extended by an AI, all stored as markdown that the user owns.

The difference, at least in how I’m using it, is that his pattern is for understanding a domain, while mine is for running one.

His state is more like a wiki. Mine is more like a set of active managers with things in flight.

If LLM Knowledge Bases organize what you know, what I have been building runs what you do.

I’ve been calling it an LLM State System, mostly as a way to refer to it.

What I notice

Every productivity tool I have used expects me to go to it. Open the app. Check the dashboard. Update the status.

This one does not work that way. I am already talking to Claude every day. The system meets me where I am. The conversation is the interface and the state accumulates underneath it without me thinking about it.

It compounds in a way I hadn’t really experienced before. Every context update, every log, every small correction to a manager’s skill file, it all persists. The assistant that helps me today is smarter than the one that helped me yesterday because it has more to work with.

A pattern that keeps showing up across different domains when I was not looking for it. No roadmap, no waitlist, not a product.

Just something I built because the tools I had were not stateful enough, and a guess that this might be useful to others as well.

About SG

I run Dobby Ads, an AI Creative Agency. I tend to overthink. This is where that overthinking goes. Connect with me on LinkedIn.

I recently wrote about something I called the Thinking Trail - a way to document the reasoning behind AI-assisted work. Five elements. Context, alternatives, assumptions, challenges, gaps.

It’s useful. I still do it.

A well-written trail looks the same whether the thinking was real or performed. It’s self-reported. And anything self-reported can be gamed.

So the question that kept nagging me: what if the trail didn’t depend on the person at all?

What if AI at work was designed to keep track?

In software, this problem was solved a long time ago. It even has a name - traces. The system-level record of what actually happened.

Nobody argues about who wrote what code. The system knows. Git tracks every commit, every change, every decision. Server logs record what happened and when. The trace is automatic. Much harder to game. You can’t easily fake a history of wrestling with a problem if you didn’t.

Knowledge work has no equivalent. Yet.

But think about where AI is going. It’s moving from a tool you visit to the environment you work in. When that happens - when the work itself happens inside AI - the system will keep the trace.

Not a journal you write about your thinking. Not a performance review someone fills out once a quarter. Not what you say happened. What actually happened - an automatic record of how you actually worked.

What questions did you ask? Did you challenge the first answer or accept it? Did you bring your own data, your own context - or just say “make me a strategy”? How many times did you push back? Where did you override the AI because something felt wrong?

That trace will look completely different for someone who thought versus someone who assembled. Not perfect. But directionally obvious.

And here’s where it gets uncomfortable. The trace doesn’t just make good thinking visible.

The person who asks shallow questions, accepts the first output, never pushes back - that’s not a suspicion anymore. It’s a data pattern. Permanent. Reviewable.

With the old proxies - degrees, titles, years of experience - you could hide. Everyone got to fake it a little. That’s bad for the system but it’s protective for the individual.

With traces, there’s less room to hide.

And who owns that data? Not you. Your employer. The platform. The system.

We wanted a world where real thinking gets recognized. We might get a world where every gap in your reasoning is logged and scored by a system you don’t control.

That line I said as a wish - “I wish my AI could tell his AI” - it won’t stay a wish for long.

The question is whether we’ll like what it reveals.

About SG

I run Dobby Ads, an AI Creative Agency. I tend to overthink. This is where that overthinking goes. Connect with me on LinkedIn.