The agent should not be the vault

If you use Grok Bot, Cursor, or Grok for anything you wouldn't post in Slack, you already know this pattern. A project for work. One for the homelab. One for training. Maybe one for health. Each of them is a pile of private context you either paste back in when the session dies, or leave sitting with the vendor because re-teaching it got old.

I've been doing that. It's a bad vault.

The session ends and the model forgets. Or the bot keeps the memory, which means a company that didn't need that file now has it in a chat log. Neither is a place I want a private life to live. The agent is good at the work, but it's a terrible place to store the briefing.

The agent should not be the vault. The drive is.

What Hoodik stops, and what it doesn't

If you are using cloud AI, the file you check out goes to a cloud. Hoodik does not stop that, that's just the reality of a cloud.

What Hoodik does stop is the other leak: the standing archive. Keys never leave the Mac, the server stores only ciphertext, and there is no OAuth grant sitting on your storage. The durable copy lives on a drive you control. The agent checks a note out for this task, the way you would paste it, and when the session dies, the briefing is still on the drive, not in a Grok Bot or a Cursor chat that has been sitting there for weeks.

A deliberate read of one file is a trade I can live with. The files you open do reach the AI vendor. There's no way around that. The standing archive stays home.

That's the cloud path. Better than treating the chat as the filing cabinet, but it is not a fortress. The fortress is a local agent.

Local agent is what closes the circle

You can already run a capable agent on your Mac, or on a box in the house. That used to be a hobby, but it's getting normal. Models are small enough now, the hardware in an ordinary Mac is enough, and the tooling is catching up. The direction of travel is not "everything lives at a vendor forever." It's agents that run next to the files.

On that path, Hoodik is not a nicer paste box. It is the same encrypted drive, doing one more job: private memory.

The Mac app already speaks MCP on loopback. The local agent talks to the app, the app decrypts, the server never sees plaintext. You can tune that agent so it doesn't keep a chat history of its own. The history, the briefing, the runbook, the thing you would otherwise dump into a project: those live as notes on the drive. The session can be empty in the morning. The drive is not.

Grok Bot is not that local agent. It is still cloud inference, which is why a checkout is still a checkout. What it is good at is the other half of this post: a crew of named bots that keep a job, not a filing cabinet. Cursor on the Mac is the door they walk through. The vault is still the drive.

None of this turns Hoodik into an AI product. The drive stays what it is, files and photos the server cannot read, and that turned out to be the right shape for an agent's memory. A tool that makes the next few years of agents more private, not a promise that cloud inference is private.

Durable like a cloud, blind like a disk

The obvious objection: if the agent runs on my Mac anyway, I could keep all of this in a plain folder and skip the drive entirely. You could, and for throwaway notes that is honestly fine.

The problem is that a local disk is ephemeral. Laptops die or get replaced, and if you are on Windows, you are probably reinstalling the whole OS quarterly anyway, together with everything that lived in that folder. The context we are talking about here, health records, the homelab runbook, years of company thinking, is exactly the stuff you want to still have in ten years. That is long-term storage, not a folder that shares fate with one machine.

The usual fix is to sync that folder to a normal cloud, and now the plaintext sits with another vendor and you are back where you started. Hoodik is the middle: durable like a cloud, blind like a disk. The server keeps ciphertext it cannot read, the keys stay with you, and the briefing outlives the laptop.

The bridge already exists

In June I wrote about connecting an AI agent to Hoodik. The short version: the Mac app runs an MCP server on loopback, and an agent gets the drive as tools. List, read, write, search, notes. Decryption happens on the device, with the key that is in memory because you unlocked the app. Enable AI Access, paste the snippet it shows you into Cursor, Claude Desktop, or a local client, and you're connected. The setup is in the June post, so I'm not repeating it here.

The crew I actually run on the other side of that door is Grok Bots. Same Mac app, same loopback, same checkout. The June post is how you plug a client in. This post is what you do with it.

Four agents, one drive

I'm actually running this, not writing a hypothetical.

A useful session used to start with me pasting the briefing in, or hoping last week's chat still had it. Now the four lives are a small crew of Grok Bots, with Cursor on the same Mac as the other client. Each bot has a job. None of them is the archive. A session starts empty: the Mac app is unlocked, the bot checks its briefing out of the drive, does the work, writes back what should survive, and that's it. The notes are still there in the morning. The bot isn't, and that's fine.

The wiring isn't clever. Every agent gets the same standing instruction: the drive is the store. Check out what the task needs, write back what should survive, forget the rest. Git keeps a pointer file. The life stays on the drive. Even the bots' own scratch lives there, in a folder per agent, so a thought can survive the chat that had it.

The work agents. The ones that are helping me build Hoodik: code, the site, drafts. The company context that does not belong on GitHub lives on the drive: positioning, the arguments I am still turning over, decisions half made. An agent checks that out before it touches a page, and the decision goes back to the drive when it is made. Public source is the evidence, the thinking stays on the drive.

The homelab maid. One agent's whole job is the house: how it is wired, what changed last time something broke, the runbook that used to live in a chat. When something breaks at 11pm, the session starts from the runbook, not from my memory of what I typed in March. The fix goes back into the runbook before the session dies.

The trainer. Liftosaur keeps the workout log, and it stays there. The drive holds the plan: what I am training for, what I am working around. The trainer reads the plan, we adjust it, the new plan goes back. The drive does not need to become a spreadsheet of lifts.

Health. The load-bearing one. The trainer and the maid are convenience; this folder is the reason the whole thing is encrypted.

It's the folder with the lab results, the findings, the referral letters, the photos of papers I take because clinics still hand you paper. It's also where an AI genuinely earns its keep: it reads a finding before an appointment and explains the words, so I walk in knowing what to ask. I use that, and I'm not giving it up.

But a health leak is not like other leaks. A password leaks, you rotate it. A health file leaks and there is no rotating your body: whatever is written in there stays true, and it follows you. My folder is nothing dramatic, mostly a knee with a dead ACL, the ligament, not the access control list, which is a strange thing for a storage developer to lose. But everyone has something, and for some people it's the appointment where a doctor does a Cameron Diaz (camera up the ass). That should stay between you and the person holding the camera, not sit in a vendor's chat log.

So health gets the strictest version of the loop. I'm not putting it in a Grok Bot as standing memory. I'm not putting it in a Google Doc. It lives on the drive, encrypted to a key that never leaves the device. No standing health agent, no ambient access. When I need one, I ask, it reads exactly what I open, and on a local agent with no history of its own, the whole exchange dies with the process. The unlocked app can search the whole drive, so the discipline is what I ask it to open. On Grok Bot or Cursor that read is a paste. Some files are worth it, most are not.

The crew is replaceable on purpose. Grok Bot and Cursor today, maybe a local model next year. The memory is the drive and the door is MCP, so swapping the agent swaps nothing else. The briefing does not move, and the vendor does not inherit my life on the way out. I don't start Monday by re-teaching anyone.

What is still true either way

A few limits, for both paths:

• macOS, app running, one account. The MCP server lives in the Mac app. The app has to be open and signed in. Sign out, and the agent loses access. There is no iOS or Android version of this, on purpose.
• Unlocked means the whole drive. There are no folder grants. If the app is unlocked, the agent can search and read anything that account can. Lock the app if you walk away. The default is that a locked app denies every tool call.
• One session, not a new identity. The agent acts as you. It does not get a lesser key. It gets the output of operations the app runs with your key.

If those constraints bother you, don't turn this on. The June post has the rest of the model: loopback, bearer token stored encrypted, rate limit, local audit log with hashed parameters, idle timeout.

The point

I got tired of keeping a private life in a chat. The chat is good at the work, but it's a bad archive.

Cloud AI will keep seeing what you open. Hoodik still wins the part that used to be worse: the briefing does not have to live at the vendor between sessions. Grok Bot is the crew I actually run on that path. Local agents are the rest of the story. Run the model next to the files, keep the history on the drive, and the vault is actually a vault.

The use case is not exotic: a crew of Grok Bots that starts every session empty, Cursor on the same Mac, and a briefing that survives without living at a vendor. Check out, work, write back, forget. The copy that matters stays where I control the keys.

If you already have the Mac app, you already have all of this. If you want the setup, it's the June post. The app is on the App Store and it talks to any Hoodik server, including one you run yourself. The server code is public, CC BY-NC. You can read it, build it, audit it. The claims here are yours to check.