Skip to content

The system

An agent OS, built from scratch.

Routing, roles, skills and memory on Claude Code, reaching real systems over MCP, with a human on anything that cannot be undone. This is the overview - each part is broken down properly in the guides.

Why I built it

I wanted leverage without headcount. Real work done by a system I could reason about, not a pile of one-off prompts. So I built an agent OS from scratch - routing, roles, skills, memory - on Claude Code. Small enough to hold in my head, serious enough to run in production.

How it works

Routing
Work lands in the right place. The system knows which agent, which skill, which repo - without me routing every task by hand.
Roles
Each agent has a seat with a boundary. Vault editor, product reasoning, code review - defined roles, not one blob of AI doing everything and doing none of it well.
Skills
Repeatable playbooks encoded once and invoked on demand. Draft the post, run the audit, commit and open the PR - the work that used to need a hire becomes a command.
Memory
Context persists across sessions in plain markdown - facts, decisions, daily logs, three tiers deep. The system remembers, so it never starts from a blank page. This is the part most people get wrong.

In depth: routing, skills and subagents and how memory is structured.

Claude Code, plugins and MCP

Claude Code runs the orchestration. The repeatable work is packaged as plugins and skills, so a job that used to take a person becomes one command that any agent in the system can call.

MCP is how it reaches the real world. I build MCP servers so an AI can drive live tools directly - create records, move money, touch the systems a business actually runs on. Not a chatbot that answers. Software that acts.

When a new capability ships, I turn it into something working in days, not quarters. That gap - between a release note and a tool you can actually use - is where most of the value is, and it is the part I enjoy most.

In depth: designing an MCP server a model can actually drive.

Auth that holds up

Here is the half that makes AI software safe to hand to a business: real identity. SSO, SAML and OIDC. SCIM provisioning. Roles, seats and spend limits.

It is the plumbing nobody demos and every serious deployment needs. I build it in, because software that touches other people's data and money has to be accountable before it is clever.

In depth: auth for agents.

A human stays in the loop

One rule I never relax. Anything public, anything involving money, anything you cannot undo, waits for a person. The agents do the work. I sign it off.

That is not caution for its own sake. Leverage without control is just a faster way to break things. The approval gate is the design, not a limitation on it.

In depth: designing the place a human has to say yes.

In production

This is not a lab experiment. It runs in production - live users, real billing, real consequences. Built, shipped and maintained end to end.

I even pulled the engine out of my own setup and it stood up as a product of its own - Corey. It built its own website and wired its own checkout with barely a hand on the wheel. If a system can build and sell itself, it can do the day job. Proof, not a promise.

This site is built and maintained by that same system, which is documented in detail on the colophon. The essays are where I work the rest out in the open.

Principles

  • Leverage beats headcount.The repeatable work should not need another hire.
  • A human stays in the loop.The system does the work; a person approves what ships. Always.
  • Reach the tools that already exist. The system connects to live software over MCP rather than replacing it. A platform everything has to migrate onto is a tax, not a system.
  • Ship small, ship often. Trust is earned one real task at a time.