The layers

Observe → Decide → Act → Govern. Sidekick listens, remembers, proposes, and — only when you allow it — acts, with every step logged and reversible. The clever part is not any one layer. It is that they are wired together around a memory you can actually trust.

Why I built it

I run several ventures at once, and I made an uncomfortable discovery — the single most expensive piece of infrastructure I owned was my own memory, and it was failing quietly all the time. A promise made on a Tuesday call. A decision that reversed itself between two meetings without anyone quite noticing. A name, a number, a “leave it with me” that evaporated the moment the next conversation began. Human memory is a wonderful thing, but as a system of record it is, to put it charitably, lossy.

Now, the temptation here is to reach for the obvious gadget — record the meeting, generate a tidy summary, offer three suggested actions. It looks marvellous in a demo and it proves absolutely nothing, because every platform on Earth already ships it. Google does it. Apple does it. It is table stakes, and table stakes are not a company.

The genuinely hard, genuinely useful thing — the thing nobody can copy in a weekend and the platforms are structurally disinclined to build — is long-horizon recall you can trust enough to act on. Memory that is relational and temporal, not a warm fuzzy vector guess. Memory that, when it tells you “you promised Simon,” can play you the eight seconds where you said it. Get that right and everything downstream — the drafting, the nudging, the quiet catching of a contradiction three meetings apart — becomes safe. Get it wrong, and a confidently fabricated obligation is the failure that kills the whole idea. So I built the hard layer first and treated the rest as plumbing.

What makes it different

Plenty of tools will happily act on your behalf. The permissive ones — an OpenClaw-style runtime that hands an agent your credentials and hopes for the best — get the autonomy exactly backwards. Autonomy is worthless, and frankly dangerous, without trustworthy memory underneath it. A PA you would let auto-answer an email is only safe because it knows who this is, what was promised, and what the thread already settled — and can show its work.

So Sidekick keeps its own loop and its own gate. It owns the boundary between “proposed” and “done”, because that boundary is the entire safety argument — which is precisely why it drops the third-party runtime and keeps only the protocol (MCP). Same connected-assistant shape as the big cloud tools; a defensible, verifiable core they don’t have.

How it is built — and how fast

Here is the part that still makes me grin. Sidekick went from architecture to a working, dogfooded assistant in about a week — because I ran the whole build through my own CodeEasy AutoCode. I designed the memory model deeply, handed the spec to the autonomous multi-agent build loop, and let the build streams run overnight. I would sketch the hard decisions by day; the machines would implement, validate and hand back working code by morning. Design deeply, then ship lean — with a night shift that never sleeps.

Where it goes

Today Sidekick is my personal tool, and an unreasonably good one. It could become a product — monetised for operators who live the way I do — or run for free inside an organisation I partner with. And for anyone who needs it, it can be completely privately hosted, memory and all, inside enterprise walls — because a second brain you can’t fully trust with your own words was never worth building.

Status

Beta — live, in daily use, and getting sharper every week I feed it.

Curious how it fits together? The full Sidekick architecture & flows — the memory model, the provenance chain and the gate — is published in the open (button up top).