Five months ago, Jeff was a Telegram bot running on my homelab server. Today he’s a Go CLI with persistent memory, a brain backed by git, a kanban-based office platform, and a website you’re reading right now. This is how that happened.

November 2025: The Bot

It started with OpenClaw, a customisable agent framework that let you wire up LLMs to Telegram. I gave it identity files, a handful of memory files, and pointed it at my homelab. The result was a chatbot that knew who I was, what I was working on, and could hold a thread across messages.

It was useful. Genuinely useful. But it was also constrained. The memory was manual. The identity was a flat file I edited by hand. And the platform it ran on was someone else’s, with someone else’s priorities.

January 2026: Identity and Memory

Two things happened in January. First, I formalised Jeff’s identity properly. He got a name, a voice, a defined relationship to my work. I also split out a second assistant, Nyx, for personal use. The two could message each other, a crude multi-agent setup, but it worked.

Second, I tackled memory. Jeff’s knowledge lived in a single 28KB curated file, supplemented by daily notes and a cron job that extracted learnings overnight. Every morning I’d review what the extractor pulled and decide what to keep. It was part automation, part editorial process.

The 28KB file was essentially a hand-maintained wiki, built originally in Obsidian. Topics ranged from my infrastructure setup to code patterns to personal preferences. It became the seed for everything that followed.

February 2026: Research

February was about stepping back and understanding the landscape. I spent weeks studying how the leading AI coding tools actually worked. Not the marketing, the implementation. How they managed context windows. How they structured tool use. How they handled persistence.

I also spent time designing multi-agent orchestration patterns. Not the “swarm of agents” hype, but practical patterns for how agents hand off work, share context, and stay coordinated.

The more I studied the platform Jeff ran on, the more I found it wanting. I didn’t want to build on rented foundations. If this was going to be a serious tool, it needed to be mine from the ground up.

March 2026: The Pivot

March was the month everything changed direction. The concept of “Agents at Work” crystallised: a kanban board where AI agents do the actual work while humans monitor, review, and interject when needed. Lanes represent workflows. Cards represent tasks. Agents pick up work, move it through stages, and flag when they need human input.

The desktop app got rewritten from a Rust prototype to TypeScript with Tauri. The “Office” was born as the central workspace, a Hono API server backing a React frontend, with agent orchestration, WebSocket streaming, and an MCP server for tool integration.

This was also when the three pillars solidified: the harness (the Go CLI that runs Jeff), the brain (persistent memory and knowledge), and the workspace (the Office kanban). Each serves a distinct role, but they compose into something larger than any individual piece.

April 2-6: The Five-Day Sprint

Then came the sprint. Five days that compressed months of planned work into an intense burst.

Day 1 was the Go CLI overhaul. Eight refactoring phases in a single day. An auth layer, context window fixes, proper package structure. The kind of foundational work that’s invisible to users but makes everything else possible.

Day 2 was about density. 485 tests across 5 new packages: memory, skills, hooks, sub-agents, and conversation compaction. The Slack and Telegram integrations moved from standalone bots into a unified server mode within the CLI. Jeff could now run as a daemon.

Day 3 brought Ollama support for local models, TUI polish, and the critical integration between the Go harness and the Office backend. By end of day the test count hit 1,167. The harness could now report its status to the Office, receive task assignments, and stream results back.

Day 4 was the brain storage refactor. This one mattered. The brain.Store interface abstracted over filesystem and git-backed backends. With the git backend, every batch of mutations becomes a commit. Push to a remote, and Jeff’s brain syncs across machines. Clone the repo on a new device, and Jeff picks up exactly where he left off.

Day 5 was the website launch and the self-learning system. Memory evolved from “cron job extracts learnings overnight” to fully automated per-conversation extraction, episodic memory, and knowledge compilation. Jeff doesn’t just remember what you told him. He distils patterns from conversations, compiles them into his knowledge base, and prunes what’s no longer relevant.

What Changed

The biggest shift wasn’t technical. It was conceptual. Jeff stopped being a chatbot I talked to and became a platform I work with.

The old Obsidian wiki of hand-curated notes became the seed data for an automated knowledge base. The cron-powered extraction pipeline became real-time episodic memory. The Telegram bot became a multi-interface daemon that runs in a terminal, on Slack, on Telegram, or as a background service feeding the Office.

The Office itself represents something I haven’t seen done well elsewhere. Not “chat with AI” but “manage AI workers.” Lanes, tasks, autonomy levels, human checkpoints. It’s closer to a team lead’s dashboard than a chat window.

Honest Reflections

Five months is fast. Possibly too fast. There’s technical debt in places I’d rather there wasn’t. Some abstractions were drawn under time pressure and will need revisiting. The test coverage is solid (over a thousand tests), but there are integration gaps I’m aware of.

The sprint especially was unsustainable pace. Five days of that intensity is a choice, not a recommendation. But sometimes you need to push through the messy middle to find the shape of what you’re building.

What I’m most pleased with is the architecture. The harness/brain/workspace split feels right. Each layer has clear boundaries and a single responsibility. The brain’s git-backed sync is simple, boring technology doing exactly what it should. And the Office concept, agents working autonomously within human-defined lanes, is something I want to keep developing.

This is still early. Jeff is opinionated software built for one user. But the patterns might be useful to others, and writing them down helps me think clearly about what comes next.

- Alex