The Real AI Limitation Isn't Missing Capability — It's the Gates Between Tools

Covers July 2026 · published August 2026

Now that I have a working AI-maintained second brain, I’ve become a bit spoiled.

If you’re unfamiliar, here’s where this started. The short version: a dedicated mini-PC runs Claude as a permanent assistant that reads, writes, and remembers a structured set of notes — everything I capture, decide, and build — entirely on its own, between sessions. It’s not a chatbot you visit; it’s a system that operates continuously under a set of rules I wrote for it, and it has held up through a month of real use. Outside that boundary is a different world entirely, and living between the two is what this piece is actually about.

The system on the inside is efficient and beautiful.

On the inside: its ability to actually code and build things, not just talk about them. Its ability to actually fix things, not just suggest fixes. Its ability to remember — genuinely, across sessions, not just within one conversation. Its willingness to meet my real, actual needs instead of a generic version of them.

Inside that system, the workflow is instant. The AI reads my notes, updates them, tracks decisions, and maintains full context across sessions. Everything just works, immediately.

The other tools I actually use tell the rest of the story. Claude has its own separate voice-enabled interface — a different tab called Chats, distinct from the coding-focused one my vault runs in. Grok has its own voice mode too, genuinely excellent — good enough that I used it to edit this very article, out loud, on the drive to work. And X is where I actually post. All three are real, useful tools. For the first two weeks, none of them talked to the vault, or to each other.

What’s been left behind: a plain chat window with no memory at all — ask a question, get an answer, close the tab, gone. A traditional notes app you have to organize by hand. And this project’s own starting point just a short time ago: a plain Grok chat with zero file access, where every note had to be copied out by hand into Obsidian. That already feels like a different era.

Both of those voice modes — Claude’s and Grok’s — are genuinely excellent for conversation. But neither connects to the vault. Using either means losing all context and starting fresh every time, even when the conversation is about the vault’s own content — I still had to paste this article into Grok by hand for it to have anything to work with. Getting Claude to read my own posts on X was blocked by API limitations and paywalls. Getting the AI to publish directly to X forced me to act as the manual middleman, copying and pasting between tools.

Outside the vault, every new chat starts from zero. There’s no persistent memory, no continuity. You lose your patterns, your history, your context, and have to rebuild it every single time.

It’s especially hard to be patient with these gaps because the speed is blinding until you hit a wall. New things are obsolete at the moment of release. We’re all dropping cool new capabilities so fast that there’s no time for a parade lap anymore. In an environment this chopped up and competitive, it’s too easy to focus on what’s still broken.

And yet — today is actually a great time to be alive.

Walled cities, not walls

The real limitation isn’t the AI itself. It’s how we currently handle the gates between these different tools and platforms. Gates exist for good reasons — security, privacy, verification, business boundaries, and safety. The problem isn’t that the gates are there. The problem is that too many of them are still slow, manual, opaque, or overly restrictive for legitimate, secure flows. We end up doing the work of moving context across them by hand, losing continuity every time.

The more I’ve actually lived inside this, the less it feels like a wall with the occasional door, and the more it feels like a highway system connecting walled cities that never signed the same treaty. Every tool — Claude, Grok, X, the vault itself — is its own sovereign city, with its own gates and its own rules for who gets through. An API isn’t a hole punched in the wall. It’s the toll road: a real route someone built and maintains on purpose, and it runs on toll revenue — literally, in the case of the X integration described further down, priced per call. That’s not a flaw in the system. It’s exactly how you’d expect a system of sovereign cities to work: they trade with each other not by tearing down their walls, but by building and pricing the roads between them.

I watched the toll booth work exactly as it should when I wired up the next tool through the same kind of system: before running a real API call to send a draft out for review, the AI stopped mid-task and said so plainly. No charge until I said go. That’s the whole toll-road idea in one exchange: the cost isn’t hidden in fine print, and it isn’t waved through by default. It’s priced, shown, and confirmed before it ever hits.

What I’m advocating for isn’t the removal of necessary gates or the walls around them. It’s recognizing that navigating this well is a logistics problem, not a one-time unlock. You don’t just find the gate and walk through it once — you learn the route, you learn what the toll actually costs, and you keep the road maintained, the same way any real trade route between real cities has to be. Where a gate adds no real value, we should remove it. Where it does add value, we should make the road through it as clean, fast, and well-documented as possible — so we can all evaluate what is and isn’t possible, and why, and keep improving the route, not just the one crossing.

Closing one of them

After about two weeks of working around it, I closed one of these gates myself, and it’s worth describing exactly how — “the gap is closing” is easy to say and much harder to actually do.

X is one of the gates named above: the one blocking my AI from posting or reading my own content directly, forcing me into the copy-paste-and-lose-the-formatting role every single article. Closing it took about two hours, and none of it was exotic. Sign up for a developer account. Write an honest, specific description of exactly what I wanted to do, and nothing more — the honesty of that description turned out to matter more than any technical cleverness, since it approved instantly. Generate the right credentials, and store them somewhere the AI could use them without the actual secret values ever passing through our conversation.

Then we tested it the way this whole system tests everything: smallest possible step first. A read-only check that the credentials actually worked, before anything else — nothing to lose if it failed. Then a real draft, not a real post, so a mistake would cost nothing. At one point the AI actually caught itself about to submit content to my real account without asking me first, stopped, and explained what it was about to do instead of just doing it. That’s not the gate failing. That’s the gate working exactly as intended, on both sides — the security boundary held, and the tool built to work within it respected it too, on its own, before I ever had to say anything.

By the end of it, the thing I’d been describing as a limitation across three drafts of this very article was just done. Claude can now create Article drafts directly, and read my own posts, without me acting as the manual middleman. The final publish is still a button I press myself — a toll booth I left in place on purpose. The formatting-loss problem is gone — not because the gate disappeared, but because we finally built the right door through it.

The lesson I’d give someone stuck at a gate like this

We weren’t sitting still those two weeks — we were actively looking for a way around this gate, or over the wall entirely. But looking isn’t the same as finding, and finding isn’t the same as knowing what to do once you’re standing in front of it. The real work wasn’t effort. It was two things: locating the actual gate in the first place, and then learning how to ask and answer each other the right questions to get through it.

An experienced programmer would have known within minutes that “check for a developer API” was a move on the board. I’m a manufacturing engineer, not a programmer — that move wasn’t in my vocabulary yet, and it took real back-and-forth between me and the AI, both of us learning to communicate about a problem neither of us had fully named yet, before the gate actually came into focus. Once it did, walking through it took about two hours. Finding the gate and building a shared language to get through it is its own real work — separate from, and harder than, the work of walking through it once it’s found.

Try this right now

Take the one workflow you currently do by hand between two tools — the copy, the paste, the reformat — and spend ten minutes finding out whether either side has a public API. Not building anything. Just finding out whether the gate has a door. That’s the step I skipped for two weeks.

If this helps you, check out my adblob to support the work.