The working record.

All of the work lives in one place, so what is learned can build on itself.

Ideas had been getting lost between tools. One place replaced them.

Every request is routed to an AI agent with a defined role, its own memory and its own scope.

One general assistant was doing everything, loosely. Each agent now runs in its own space and is briefed before every decision, with a person over it.

• Where shared context ends and isolation begins is written down: shared tools work in the room, agents run in a quiet one.

The whole path is checked end to end before anything is called done.

A screen that reported healthy was quietly dropping updates. Two parts of the system disagreed about the shape of the data, and each looked fine on its own.

• Posts went live in public and never reached the internal record. Fixed, then guarded so the same fault can no longer pass silently.

Before any retry, the record is searched for the same error. Two retries is the ceiling; the third time escalates.

The same error was being solved more than once.

• A day lost to a doubled tool ended in a written workaround, so nobody chases it again.

The software and the knowledge live apart.

The workspace was split in two: one side for the tools, one side for what they manage. The tools stay light; the knowledge can grow without friction.

• The three layers of memory were drawn on paper before a line of code.

One place shows who did what, when, and why.

A task board grew into one place with roles, activity logging and audit trails.

• Errors are captured the moment they happen, with a severity and a way to mark them resolved.

Schedule what is repeatable. Direct what is creative. Keep a person in the loop for anything that cannot be undone.

One pattern for every automation, drawn once. Every new workflow is checked against it.

Every task points back to the plan it belongs to.

Tasks and plans were two islands. A task could ship without ever naming the plan it served. The link was added and the history filled in.

Everything published is something learned from building, reviewed before it goes out — and the record itself is published as it happens.

The first brand guidelines went through four reviews in parallel: voice, visual, positioning, compliance. Regular publishing started the same month, and this page grew out of it.

• One writing protocol for every public piece, on every channel.

An agent's permissions are checked, never assumed.

Agents had wider access than anyone believed, because one setting had been read wrong. What an agent can reach is now verified and written down.

Every task, decision and session has a permanent record, and every session ends with what was done, what is open and what comes next.

Important things had lived only in a chat, and sessions had ended with loose threads. The whole record moved onto a database, and each session now closes in writing.

Work that no longer serves the stated direction is stopped.

Every active workstream was run against the company's direction. Three were paused.

A change with a wide blast radius is audited before it is scheduled.

A planned overhaul would have touched most of the record at once. It was paused after an audit, and re-planned in smaller steps.

Every decision names the trigger that caused it and the alternatives considered.

The existing record was audited against the new bar. Entries that fell short were rewritten to meet it.

Any step can be re-run or rolled back without losing the work before it.

A failed step used to cost everything upstream. Now each step can retry or roll back on its own.

• Duplicate checking moved to the intake step: cheaper, and safe to run twice.

Nothing we build makes you dependent on us.

Written down as permanent, so no later convenience can move it: your content stays where you put it, and nothing changes your files without you.

We lead with the method, never with a product.

Until July the site led with a product. Someone arriving cold has not asked about a tool, so the order was reversed: the method first, and the tools only as parts the work needed.

We own the stack the work runs on, and the build checks every page before it can ship.

A page-builder could not do what these pages need. Since July every page is plain HTML that a person and a machine can both read, and a set of checks runs before any of it can ship.

Where a business stands is stated on a seven-rung ladder that anyone can check.

The ladder page shipped as the first instrument: seven rungs, each defined in plain words.

No invented people, ever.

Since August, every name, title and quote on this site is checked against a real person, or it is removed.

Plain language, enforced by the build.

Since August a check measures every page's copy, and refuses a build that a reader without a technical background could not follow.

The gaps are content.

Where we have not done something yet, the page says so, in those words. Filler is never used to cover a gap.

Scope is held to the phase that was agreed. Widening it is the next phase.

Every engagement asks to widen scope mid-build. The answer is written down in advance: that is the next phase, and it will be faster because the foundation exists.

Nothing is ever written back into your systems of record.

Data is copied out. On the copy, real names are swapped for stable codes, and only that copy travels onward. Access is read-only, and the shape of your database is never changed.

A client's country and sector are never published together, and no client's staff are ever named.

Either fact alone is harmless. The pair identifies a company, and the work holds assessments of individual people.