Minds improvise. Tools organize.

Work outgrew the way we organize it

Today’s tools organize files, name things fragilely, lose the judgement behind every outcome, and hand agents far more reach than the task needs. Each failure grows with every agent added.

1. 01

   Documents are mistaken for the work

   A renamed file looks like a new thing. A moved file looks like a change of status. A folder called done/ becomes a second, competing answer to whether something is finished.

2. 02

   Identity is fragile

   Paths move, titles change, and a central counter makes uniqueness depend on one service staying up while parallel agents race for the next number.

3. 03

   Judgement goes unrecorded

   Records capture what changed — rarely who decided, on what evidence, against which alternatives. When a claim turns out wrong, it is edited, and the evidence that anyone believed it is gone.

4. 04

   Agents get too much reach

   Handed a whole repository, a broad tool surface and write access everywhere, one mistaken run damages work it was never asked to touch — and an agent that approves its own output proves nothing.

5. 05

   Process weight is guesswork

   Ceremony follows how important work looks. But importance is the wrong variable: trivial work that cannot be undone needs a gate, and important work that is easily reversed does not.

6. 06

   Parallel agents collide

   Many agents race on shared status fields, overwrite each other's files and coordinate through notes. Who owns what, what is ready, what is left — all left to convention, so all of it drifts.

Simple is proven inadequate. The answer is not less process — it is process that decomposes into light, checkable work.

Artifacts, not documents

The thing being organized is the idea, the decision, the result — not the file that happens to describe it. Activities connect artifacts on one provenance backbone.

A document is a representation. The artifact — the idea, the specification, the decision, the result — has an identity of its own and outlives every file that ever described it. Rename the file and nothing about the artifact changes; move it and its status does not move with it.

Artifacts are connected by activities, on the model of W3C PROV: an agent was associated with an activity, which used some artifacts and generated others. A real lifecycle branches, loops and revisits. A causal graph can say so. A flowchart cannot.

Relations point upward, child to parent, like a foreign key. A parent never lists its children — “what did this produce?” is a query. That is not tidiness: every reference is pinned by digest, so a parent that listed its children would have to be rewritten, with every ancestor up to the root, each time one leaf was added.

Agents judge. Tools do the mechanics.

An agent decides only what words to use, what to name, how to build. Every mechanical act — minting, validating, recording, verifying — is a tool, served over MCP.

The role is the act, not the actor. A mind can do organizing work — an AI model can sort an inbox or propose a link — and a person can follow a fixed procedure like a tool. The act decides how the result is trusted: output that is deterministic and replayable counts as a tool’s; anything else is a judgement, recorded as a choice among declared options, with who answered.

No command both queries and writes. A tool may detect that a judgement is required; it may never make one. Agent prose is inert: an agent that needs a fact recorded calls a tool and is admitted — it does not write “all tests passed” and hope something believes it. The rules are Datalog: always terminating, order-independent, side-effect free, so every guard is decidable and every “blocked” comes with its proof.

A tool computes which judgements are required, and whether they have been given. It never gives one.

Work goes out as a brief and comes back as evidence

A bounded agent receives a sealed bundle with everything the task needs — including when it is done and when it cannot be done — and returns one signed bundle of everything it produced.

brief    sha256:9c41…e07a
inputs   spec-…-k2r8wd @ sha256:3b1e…  read
         repo  @ 4f0c2a1          read
         src/sync/                write
entry    spec.accepted ∧ lease.held
budget   400k tokens · 1h · reconsider ×1.5
done     retry.backoff ∧ tests.pass
cannot   provider.api.absent → blocked
commands fs.write test.run act.propose
nonce    7f3a…

Nothing is overwritten. Everything is superseded.

Exactly three things are ever written — manifests, events, blobs — and none of them changes. State is a fold over the record, so every past state is a query.

Anything that happens after a record is written is a separate record that refers to it, never a field edited onto it: an acceptance, a defeat of a claim, a supersession of a decision, an expiry. A correction adds; it never erases. So the system can say both “this does not hold” and “someone claimed it did — here is who, when, and what defeated it.”

state(T) = fold(every record written at or before T) — no write conflicts on state, because nothing writes state.

Four layers, one truth

Authored text people read, an immutable operational history, content-addressed evidence, and projections that can be deleted and rebuilt at any moment.

1. Projections

   rebuildable

   Knowledge indexes, current-state caches, generated views, RDF and JSON-LD exports — fast lookup and interchange.

   • Authoritative Never. Delete any of it and rebuild it from the layers below.
   • Scale whatever is useful
   • Addressed by query

2. Authored text

   Plain Markdown with flat frontmatter, tracked in Git: the artifacts people read as prose, and the definitions of every kind, field and relation.

   • Authoritative Yes — the normative layer.
   • Scale thousands
   • Addressed by identity and path

3. Operational history

   Git objects reachable by custom refs, never checked out: activity events, run chains, leases, bundle manifests.

   • Authoritative Yes — for what happened.
   • Scale millions
   • Addressed by identity

4. Evidence

   Content-addressed blobs: transcripts, logs, traces, test output, bundle contents. No rule may read their bytes directly.

   • Authoritative Yes — by digest.
   • Scale billions
   • Addressed by digest only

Code stays where it already lives. Repositories are highly organized by their own conventions; the scheme refers to them by pinned reference and never copies or reorganizes them. Finding is a query, never a directory walk.

Big work becomes small, checkable tasks

What must be produced depends on what is at stake. How hard it is checked depends on size. Big work never gets more ceremony; it is broken down until every piece is small enough to check.

1. Layer 1

   What must be produced

   keys on Consequence

   breadth of who is affected · external visibility · reversibility

2. Layer 2

   What may be reduced within that

   keys on Size, complexity, competence

   a step may be discharged in one line, with its reason

3. Layer 3

   How hard the result is checked

   keys on Size, novelty, track record

   size is never a reason to produce less — it is a reason to be checked harder

No step is ever skipped. Any step may be discharged in one line — with its reason.

Over-decomposing wastes bounded effort. Under-decomposing can make work too large to verify at all. So the bias is toward smaller, as a consequence rather than a taste — and measured agent reliability agrees: the task length agents finish 80% of the time is four to ten times shorter than the length they finish half the time.

Try it: you are the agent

Write something. Watch a tool mint it, version it, refuse to forget it, and sign it — and watch the signature break the moment the bytes change.

Values, given teeth

Twelve humane northstars for any team — of people, AI or both. Every mechanism here is one of them, made enforceable.

Every new member of a team brings none of the unwritten rules the team runs on — and an AI agent is the extreme case. It starts every session with no memory of the last, takes the easiest path every time at a scale no person could, and sounds equally confident whether it is right or wrong. Northstars are those norms made explicit — few enough to hold in mind, sharp enough that any two agents, human or not, would agree whether a piece of work honors them.

4 constellations · 12 northstars