How I Get More From AI Than Most People

I think more and more of our lives are going to pass through AI.

The work you do, the way you communicate, the decisions you make, the research you collect, the projects you run - more of it is going to involve a model or an agent somewhere in the loop.

For some people, that will be huge leverage. It will make them much sharper. For a lot of people, it is also going to make them lazy, sloppy, and dependent.

The difference is context.

It is not about better prompts

People still talk about AI as if the main game is finding the best prompt, the best wrapper, or the best model.

Those things matter, but they are downstream of something more basic: what does the model know when it is trying to help you?

Right now these systems do not have human-like memory. They are not slowly becoming familiar with your life the way a friend or colleague would. There is a context window, and there is whatever gets put into it.

That is the whole game.

The model providers understand this. That is why every major lab is racing toward continual learning and scaffolding memory into their products. When ChatGPT remembers your name or Claude stores a few facts about you, it feels useful. It is useful. But it is also shallow, fragmented, and locked inside one provider's product.

Your real context is much richer than that.

It is your ideas, research, projects, goals, side projects, relationships, notes, conversations, questions, and the things you are trying to understand. More importantly, it is how all of those things connect to each other.

Those connections often matter as much as the items themselves.

Do not outsource your context

If your context is the thing that makes AI useful, you should not hand the whole thing to one provider and hope they extract the right parts for you.

You should externalize it.

That means building a context corpus that is outside any single chat product. It should be local or at least portable. It should be inspectable. You should be able to correct it, delete it, add to it, and shape it intentionally.

Most people already have some version of this. A Notion workspace. An Obsidian vault. A folder of markdown files. Notes scattered across apps.

That is better than nothing. I like Obsidian. I like local files. But once you start working with agents, I think a simple database becomes the better abstraction.

The reason is boring and practical: agents need structure.

They need to be able to search, retrieve, update, and connect things without turning your knowledge base into a pile of duplicated markdown. They need to understand what a thing is, why it matters, where it came from, and how it relates to the rest of your world.

That is what a local SQLite graph gives you.

The shape I use

RA-H is basically a local database with an interface on top.

The main table is nodes. A node is an atomic unit of context: a book, podcast, idea, person, project, insight, conversation, article, or source.

Each node needs a painfully explicit title and description. Not clever. Not poetic. Explicit. The description tells the model what the thing is and why it belongs in the graph.

The second important table is edges. Edges are the relationships between nodes. This matters because your knowledge does not exist as isolated notes. An idea came from a podcast. A project depends on a person. A question contradicts another belief. A research thread informs a product decision.

If the relationship matters, it should exist as data.

That is the part most note systems fake with backlinks. A backlink says two things are connected. An edge can say why.

Hub nodes become a map of your life

Over time, the important things accumulate more connections.

In my own graph, there are hub nodes around the biggest areas of my life and work. When I add a new source or insight, it usually connects back to one of those hubs. That gives both me and the agent a living map of what is actually important.

When I start a task with Claude Code, Codex, Cursor, or any other external agent, I want it to read from that graph first. I want it to know the relevant projects, decisions, preferences, people, and previous work before it starts giving me generic advice.

Then I want it to write back when something important happens.

That is the flywheel:

1. The agent reads the right context.
2. The agent does better work.
3. The agent writes back durable context.
4. The next session starts smarter.

This is how I get more from AI than most people. Not because I have a magic prompt. Because I have been building the substrate the agents read from.

Why this matters now

The labs may eventually solve continual learning. Maybe models will learn on the job in a more human way. Maybe not.

Either way, you still want to own the context layer.

If the useful record of your life and work lives inside one provider's hidden memory system, you are locked in. If it lives in a local graph that any agent can read from and write to, you can switch tools without starting from zero.

That is the move.

Build your external context. Make it structured. Make it local. Make the relationships explicit. Let agents help maintain it, but do not let them own it.

That is what RA-H is for.

You can try the Mac app, or use the open-source repo if you want to run it yourself.

If you want the longer setup walkthrough, start with the open-source knowledge base post.