← Journal

Why I Built Sidekick: A Second Brain That Can Prove It

The most expensive infrastructure I owned was my own memory, and it was failing quietly all the time. This is why I built an AI assistant around trustworthy, verifiable memory instead of another summariser — why the permissive agent-runtimes get autonomy backwards, and how CodeEasy AutoCode built the whole thing in a week while I slept.

Sidekick — an assistant whose overview leads with a kill switch and the line "memory you can verify".

The most expensive thing I owned was failing quietly

I run several ventures at once, and somewhere along the way I made an uncomfortable discovery. The single most expensive, most load-bearing piece of infrastructure I owned wasn’t a server or a codebase. It was my own memory — and it was failing all the time, quietly, in ways I only noticed after the damage was done.

A promise made on a Tuesday call. A decision that reversed itself between two meetings without anyone quite registering that it had. A name, a number, a “leave it with me” that dissolved the instant the next conversation started. Human memory is a genuinely wonderful thing — associative, creative, forgiving. As a system of record, though, it is, to put it kindly, lossy. And when you are the connective tissue between a dozen moving parts, every dropped commitment is a small, compounding tax on your credibility.

So I built Sidekick — an AI personal assistant — to stop paying it.

The trap everyone falls into

The obvious move, when you decide to solve this, is to reach for the gadget everyone already has in mind — record the meeting, generate a tidy summary, offer three suggested actions. It demos beautifully. It also proves precisely nothing, because every platform on the planet now ships it. Google does it. Apple does it. Your phone probably did it to a conversation this week without asking. It is table stakes, and table stakes are not a product.

The genuinely hard thing — the thing nobody copies in a weekend and the platforms are structurally disinclined to build — is long-horizon recall you can trust enough to act on. Not a warm, fuzzy, vector-similarity guess at what you might have discussed. Actual relational, temporal memory. Memory that treats a commitment as a first-class object — who owes what, to whom, by when, and whether it’s still open. Memory that, when it tells you “you promised Simon an intro,” can play you the eight seconds of audio where you said it.

That last part is the whole game. It converts “trust the AI” into “verify the source.” A remembered fact that can’t point back to the utterance that created it doesn’t get surfaced as a fact at all — it gets surfaced as a question. That single rule is most of the trust model, and trust is the only thing that makes any of the downstream cleverness safe.

Why the other tools get it backwards

There is a whole category of tools now that will happily act on your behalf — the permissive agent runtimes, the OpenClaw-style frameworks that hand an autonomous agent your credentials, point it at your inbox, and rather hope for the best. I understand the appeal. I also think they have the problem exactly upside down.

Autonomy without trustworthy memory isn’t a feature. It’s a liability with good marketing. An assistant you’d let auto-answer an email is only safe because it knows who this person is, what was actually promised, and what the thread already settled — and can show its working. Bolt real execution onto a shaky inference and you don’t get a helpful robot; you get a confident, tireless intern making irreversible mistakes at machine speed.

So Sidekick is built the other way round:

  • The memory layer comes first, and it’s the only part I treat as the company. Everything else is plumbing — sensors on one side, hands on the other.
  • The gate is architecture, not a checkbox. Every capability is a switch — Off, Suggest, or Auto. Drafts are staged, never sent, until I confirm. A kill switch holds the entire system at Suggest. Nothing reaches a real tool without clearing that boundary.
  • It keeps the protocol, not the runtime. It speaks MCP directly to the tools I already live in — email, calendar, GitHub, Linear, CRM — so I get the integrations for free, but I own the loop and the gate. That ownership is the entire reason to drop the permissive third-party runtime, not keep it.

Same connected-assistant shape as the big cloud offerings. A defensible, verifiable core they simply don’t have.

What it’s actually done for me

The point of all this isn’t elegance — it’s that my days got materially lighter. Sidekick catches the commitment I’d have forgotten and surfaces it at the moment it becomes relevant, not three weeks too late. It notices when a decision I made in March quietly contradicts one I’m about to make in June, and it asks. It drafts the follow-up, grounded in what was genuinely said, and waits for my nod. I’ve stopped being the fragile, lossy system of record for my own ventures — and that turns out to be an enormous amount of reclaimed attention.

And crucially, because always-on capture records other people, privacy isn’t a marketing bolt-on — it’s baked into the schema, per utterance. The whole thing can run completely privately hosted, memory and all, inside its own walls. A second brain you can’t fully trust with your own words was never worth building.

Built in a week, mostly while I slept

Here’s the part that still makes me grin. Sidekick went from architecture to a working, dogfooded assistant in about a week — because I ran the entire build through my own CodeEasy AutoCode.

The operating model is the same one behind everything I ship: design deeply, then build lean. I did the expensive part myself — the memory model, the commitment schema, the provenance chain, the gate. That’s the thinking no agent can do for you. Then I handed the spec to AutoCode’s autonomous multi-agent build loop — a Codex implementer paired with a Claude validator — and let the build streams run overnight.

That’s the rhythm that made a week possible. By day I’d make the hard decisions and sketch the next stretch of the map. Overnight, the machines would implement, validate, and hand back working, checked-in code by morning. I’d wake up, review the night shift, correct course, and set the next run going. A build loop that never sleeps, pointed at an architecture that already knew where it was going.

None of that would have mattered without the design being right first — AutoCode builds fast, not psychic. But once the thinking was done, the distance between “I understand this deeply” and “it’s running and I’m using it” collapsed from months to days. That collapse is, more and more, the actual competitive edge — and it’s exactly what I’m building tools to give other people.

See Sidekick →

Related product
Sidekick Conversation becomes executable memory.