I Gave My Company Brain a Feedback Loop

The filing cabinet

Since March, I’ve been using a shared memory layer I now call OrbitBRAIN. The idea and the first name came from Nate B. Jones’s YouTube channel. I called it OpenBrain for months, but since that was his term, I eventually changed it. All my AI tools (Claude Code, Kiro, Codex, and Pi) read from and write to this system. Session notes, decisions, client context, and important details all go into one place, so any new agent starts with what the last one learned. I’ve mentioned it briefly in earlier posts, like the one about the kanban dossier and my Level 5 guardrails project, but I haven’t given it a proper introduction until now. In short, it’s the closest thing my one-person company has to institutional memory.

At first, it worked like a filing cabinet with a good search function. I added memories, and if I needed something, I could find it quickly. For the agents, this setup was mostly fine. When an agent researched for me, it could figure out the right context because it didn’t just search once. It would try different queries and filter the results until it found what it needed.

I noticed a problem in another place. My kanban board has a widget called the dossier, which shows what OrbitBRAIN knows about the card I’m viewing. Most of the memories it displayed were low quality: loosely related session notes, old status updates, and a mix of unrelated information. The dossier only gets one chance to retrieve information, and there’s nothing smart in between to try again if it misses the mark.

I didn’t realize what was happening at first. Instead, I just started using the dossier feature less and less. That’s how memory rot shows up: not as obvious errors, but as a slow loss of attention.

The realization

One day, I watched a YC video about self-improving companies, and it triggered an idea. While watching, I wondered if I could use the concept of memory synthesis in my own system.

I realized I needed a way to organize individual memories (whether I or an agent stored them) into something that shows the current state of a project, like a brief. So, we started classifying each memory under a project when it made sense, and linked those projects to specific customers. This list of projects became the foundation for everything else.

The loop

When people ask what I built, I say my context engine improves itself overnight by turning raw memories into a summary of each project’s current state. I usually leave it at that, since it sums up the whole system. Every night, for each project, the system turns raw memories into a new brief, replacing the old one. Agents and the dossier use this brief instead of just searching through raw data.

Here’s what happens behind the scenes. Four parts of the system run while I’m asleep.

First, there’s the sensor. Whenever the system gets a question (like an agent search or a kanban dossier lookup) it records how well it answered, what was asked, and how close the best match was. It also logs weak answers, which is important for improvement.

Next is the actor. At 05:00 UTC, an assigner takes any new memories that don’t have a project and files them into the right one. It’s careful: it only assigns to existing projects, never moves anything that’s already filed, and does nothing if it’s unsure.

Then comes the synthesizer. At 06:00 UTC, it rewrites each project’s brief using the new memories the assigner just filed. The new brief replaces the old one, but the old versions are kept and marked as outdated in case I ever need to look back.

Finally, there’s the reporter. At 07:00 UTC, a monitor checks the system’s data and posts a gap report to Slack. This report lists projects that haven’t been synthesized, cards without a project, and searches that didn’t return anything useful.

So the system logs, files, rewrites, and reports. By the time I start my day, everything is organized, each project’s brief is current, and any gaps are sent to me in Slack, where I spend most of my time.

A Level 5 system, built at Level 4

I call this loop Level 5 autonomy, based on the five-levels framework I’ve used all year. The assigner doesn’t wait for my approval. It acts on its own, and I review its work afterward. When I first built the assigner, it needed my confirmation for every step, yet I quickly realized I was slowing things down by having to approve everything before changes happened.

While writing this post, I used OrbitBRAIN whenever I couldn’t remember certain details. I remembered the big decisions, but some specifics (like which job runs first or when I changed the assigner’s process) had faded. The system’s briefs helped me recall these details, which made writing faster. Of course, this isn’t completely risk-free. If the system has something wrong and I can’t remember the truth, there’s nothing to catch the mistake. That’s a topic for another post.

I don’t really say, “I built it.” What actually happened is that the idea came from a YouTube video, and I worked out the design before writing any code. I used a tool that asked me questions until I had written down the goal and the outcome, and those answers became the architecture decision record. After that, I created the issues, Claude wrote the code based on those decisions, and I reviewed and approved the merge requests. The system runs on its own now, but building it was a guided process. In YC’s version of this story, agents create their own tools. Mine doesn’t do that.

There’s one more detail: the gap report, which is the nightly loop’s output. Most mornings, I just glance at it and move on. There’s too much friction to act on what it tells me. The loop runs and leaves me with a list of tasks. I already know the solution, thanks to the assigner: instead of just describing the work, the system should do it and leave an audit trail for me to review. The report should only include decisions that need human judgment. I started this project because I caught myself ignoring the dossier. Now I’ve caught myself ignoring the gap report. Same symptom, new surface.

Why a company brain only compounds if it curates itself

YC has now given this idea a name. Garry Tan open-sourced his version, GBrain, on April 5, and “Company Brain” became one of YC’s official startup requests. Tom Blomfield summed it up: “Every company in the world will need one.” He’s right. Running one since March taught me something else: if a company brain can’t organize its own memories, it quickly turns into a pile of disconnected information, and every agent that uses it inherits the mess. Mine has 3,692 memories now, with the oldest being a hydroponics mixing guide from nine months before the brain existed. The pile grows every day, and no one has time to curate it manually. A company brain only compounds if it curates itself. Mine started doing that in June. The next step is for it to curate its own report.