The Agent Bench

Every new AI project started the same way. Copy the agents folder. Copy the skills. Re-add the MCP servers. Re-explain my whole life to a fresh chat window. The work compounded; the setup never did.

The tools get smarter every month. The workspace around them stays dumb. What I wanted was closer to a wood shop than a chat: one bench, tools on the wall, sawdust swept up by someone else overnight.

What it is

One folder holds the agents, tools and routines I use across projects:

• An orchestrator and seven scoped agents. The root agent breaks work down and hands it to a specialist: architect, coder, engineering manager, archivist, curator, plus a creative director for brand and copy and a QA agent that gatekeeps production pull requests. The five core roles ship for all three CLIs; QA runs on Codex and Claude, creative direction on Claude only. Each one owns its lane and nothing else.
• Vault Brain, a second brain in plain Markdown. Clip a web page in your browser and a background job reads it overnight, files it into a wiki, and cross-links it to everything you already know. Raw notes get the same treatment. Nothing evaporates in chat history.
• Background jobs that keep it honest. Daily ingest, a Friday close-out that summarizes the week, a Monday job that starts the next one, a health check every four hours, and an hourly sync that keeps new skills stocked on the shelf. When something breaks, the system says so before you notice.

The template runs on Codex, Claude Code, or the Gemini CLI, and picks up the GitHub CLI and Playwright when they are installed, so the agents push code and test pages as shell commands instead of burning tokens on plumbing. Built for the Mac first; the agents and the vault run anywhere the CLI does. If you want the same bench without the night shift, that is Agentic Light.

The UX thinking

• One owner per layer. Delivery owns the projects, automation owns the schedule, knowledge owns the vault. Nothing falls between the cracks because every crack has a name on it.
• Boring formats win. The vault is plain Markdown and the files are the store. If I walk away from every tool in this stack tomorrow, the knowledge walks with me.
• The system reports its own health. Trust in automation is a UX problem, and visibility is the fix. A status page tells me which job failed while I slept and what to do about it, and the docs ship with a failure-mode playbook: what breaks, why, and the exact prompt to hand a model to fix it.

The light fork: Agentic Light

The Agent Workspace Template runs all night. Daily ingest, a Friday close-out, a health check every four hours. That is the right shape when you live in it. It is the wrong shape when you want to point an agent at one repo for an afternoon.

Agentic Light is the same bench with the night shift removed. No scheduler, no background service, no retry queue. You start it by hand, one provider runs once in the foreground, and you watch what it does.

What the light fork is

A small fork you specialize once, then run by hand:

• Six roles, cut down to what you need. It ships as a generic fork with architect, coder, engineering manager, curator, creative director and QA. Run one script and it becomes a specific tool: you pick the roles, the gates, and the skills the router may reach for.
• Six presets to start from. A web app, a CLI tool, a data pipeline, a design review, a server review and a WCAG audit. Each preset decides which roles switch on, which gates run before a pull request opens, and which skills are on the shelf. The WCAG preset runs Playwright, axe and a VPAT lint.
• Four providers, one run. Claude, Gemini, Codex or Ollama, in the order you set. If the first choice is missing, the launcher falls back before anything starts. Once a run starts it is never retried, and Ollama will not run a workflow that writes. A fake-binary test suite covers all of it without touching a real provider.
• A second brain that knows the project. Plain Markdown records with offline full-text search and optional Ollama embeddings. When you ask for it, a context packet gets prepended to the coder's prompt. The index is disposable and rebuilds from the files, so the Markdown stays the store.
• A dashboard that reads its own config. A static microsite shows repo health, every preset, and which roles each one switches on. The preset and roster pages are generated from the config files, and it opens straight from a folder, with no server and no build.

The UX thinking, without a night shift

• Nothing runs that you did not start. Every background job is a place for something to fail while you are not looking. Removing the scheduler removes that whole class of surprise.
• Specialize once, commit the result. Specializing writes three config files: the active roles, the gate list and the selected skills. In a fork you commit them, so the setup lives in the repo, not in anyone's memory.
• One human gate, and it does not auto-approve. The gates you picked run first. Then the run stops and waits for a yes at the terminal. Only after that can anything open a pull request.

The future of a workspace is not a grand digital mansion you maintain forever. It is a bench that sharpens its own tools and remembers everything you put down on it. The repository is private; this case study shows how I use it.