Coming soon
empty-shell
One repository to start a project with an agent: the rules, the checks and an empty wiki, with enola, tabula and taha inside, built to work as one.
- Role
- Author
- What
- A starting repository for a project run with an agent, with three tools inside
- The family
- enola, the open-source engine, with tabula and taha
- For
- A person or a team that lets agents do the work and wants to stay in charge of what is decided
- Status
- In private development, open source soon
Three good tools are not yet a way of working.
A map of the code, a place for decisions and a harness that runs agents are each useful alone. The weeks go into wiring them together: which rule is held by which check, what an agent may do without asking, what counts as done, and where a decision lives so the next agent finds it.
empty-shell is that wiring, done once. It is a repository with nothing of yours in it yet: the rules an agent works by, the checks that hold them, and an empty wiki for what the project learns and decides. Three tools ship inside it, set up to work together. It is how I start a project now.
The family.
-
The shell.
A repository you make your own: the rules an agent works by, the skills and commands it uses, the hooks and checks that hold those rules, and an empty wiki. You name your project and its repositories, and start working.
-
enola sees the code.
enola is the open-source architecture graph by Dejan Menges, which I help build. It reads every repository of a project into one graph, with no model in the loop, so “what breaks if this changes” has an exact answer and a team’s laws are graded on every change. The shell carries my own build of it: before a change goes into that build, it is measured against upstream enola on a corpus of 90 repositories, and every difference has to carry a reason.
-
tabula holds the intent.
tabula keeps the pages: what the system is, what it should become, and which decision governs which file. It validates and indexes them, runs the checks, and judges finished work against what was asked, without asking the agent that did it.
-
taha does the work.
taha runs a coding agent on a piece of work inside a mandate: which repositories, which acts, what budget, until when. A killed run resumes without repeating anything, and every outward act is journaled before it runs.
-
Each does one job.
Dependencies point one way. taha uses tabula, and tabula never knows taha. enola is the engine under both: when tabula needs something the engine lacks, it is built into the engine, never worked around.
What the shell holds.
Theme by theme. Working today means built and in use on my own projects, though not yet released.
-
Working today
Every rule says where it is carried.
The rules are one file an agent reads first. A register beside it names, for each rule, the hook, the check or the test that holds it. A rule held only by words is counted as words, so I can see which ones an agent could still talk its way past.
-
Working today
Intent before code.
Work starts as a pitch, becomes a plan with acceptance a tool can measure, then a decision, then code. The first edit into a file that a decision governs is held once, with that decision shown. At the end the work is judged against its acceptance lines, and the verdict is written beside the decision.
-
Working today
What reaches other people stays mine.
An agent commits on my machine and reports. Promoting work is my call, made each time. Anything public (a push to a public repository, a comment others read, a published site, package or release) is never done by an agent: it prepares the act, and a hook refuses the act itself.
-
Working today
Four roles, and a bet before any code.
Gambler, PM, Tech Lead and Developer ask whether, what, how, and then build. Before code is written, a pitch meets the cheapest measurement that could kill its premise, and where the roles disagree, the disagreement is recorded with the outcome.
-
Working today
A mandate for unattended work.
The shell starts with the narrowest mandate that lets a first piece of work run: branch work is allowed, a push and a draft pull request are asked, a comment is never made, and the run has a budget and an end date. I widen it by editing one page.
-
Working today
Checks that run where the work is.
One gate on my own machine validates every page, checks that every cited source and link is there, grades the architecture laws through enola, and reads again the plans a change touched. Nothing is promoted past a failing gate.
-
Working today
An empty wiki with a shape.
Three levels (the knowledge base itself, the organisation, each repository) and three layers for each repository: what it is, where it is going, and how it got here. Sources go in unchanged and are never edited, and every claim cites one.
-
In progress
One step to set up.
The three tools ship inside the shell as ready programs with checksums, and one script unpacks them, links the hooks and runs a first check. The setup downloads nothing and publishes nothing. The Linux build for Intel is run, and the shell’s own checks pass with it; the Mac and ARM builds are made and wait for their first run.
Coming soon
Open source, soon.
empty-shell and the three tools inside it are in private development, and I run my own projects on them today. They open soon. Until then this page says what the family is in words; real runs and screens come with the release, as on the other tools’ pages.
If you want to start a project this way before then, write to me.
What it shows about how I work.
I let agents do the work and keep people in charge of what is decided and what is published. empty-shell is that way of working with nothing in it yet: every rule written down, each held by something that can refuse, and three tools that each do one job. I build it for my own projects first.
How I work with knowledge bases
- tabulaholds the pages, the checks and the judge; coming soon too
- taharuns an agent inside a mandate; coming soon too
- enolathe open-source engine of the family, which I help build
- How I work with knowledge basesthe practice the family carries
- pi-brainan earlier tool, for the pi coding agent; public today