TL;DR: MarTech Ledger publishes dated, source-linked facts about 15 marketing platforms every day, and no person reviews each record before it goes out. In the first three parts of this series I was always there to catch what the system got wrong. Here I am not, at least not per record, so the work I used to do in the moment had to be done in advance, in a specification with ten principles and in a decision log that held 83 entries after its first 41 days. In a system with no operator per record, the spec is the operator.
When I launched MarTech Ledger at the end of October, the moment that stayed with me came a few days later, reading a feature record on a platform I know well, written that morning, and realising that somebody else might already have read it before me, on a vendor’s product team or in a consultancy preparing a selection, and nothing I could do now would change what they had seen.
That is a different situation from the one the first three parts of this series describe. The first part was about the written context a forgetful collaborator needs, the second about failures that pass every check, the third about turning repeated prompts into procedures. In all three there was a constant I barely mentioned because it was always true: I read the output before it shipped. An article on this site does not go out until I have read it, and most of the rules in those articles exist because I caught something on a Friday and wrote it down.
When nobody is in the loop, the rules have to exist before the run
I closed Part 3 by saying that this series stopped where a second person could trigger the same procedure, because that is where identity and authority begin. The Ledger did not add a second person. It removed the first one from the record level, and that turned out to raise a separate set of questions which still fit inside one operator’s experience.
The scale makes the point quickly. With data as of 14 November, the public record held 2,464 feature records and 67 market signals across 15 platforms from 11 vendors, in three categories (CEP, CDP and B2B marketing automation). The pipeline reads 21 monitored vendor sources, 20 of them daily and HubSpot Community weekly, keeps 7 more as history-only archives, and runs 15 MarTech Watch lanes alongside them for announcements. Reading even the new records of a busy week would take most of my evenings, and the site’s Methodology says plainly that there is no per-record human verification. That sentence is public on purpose, and it is the design constraint the rest of this article follows from.
I want to be precise about what “no operator” means here, because it is easy to overstate. There is a person, and it is me. I review the rules, I approve every change to the taxonomy, and the corrections register, which held 431 entries on 14 November, lists changes I reviewed before they altered a published fact. A pull request that fails validation waits for me. What there is not is a human between the model’s output and the public page for any given record. The judgement I used to apply to each article has to be applied once, upstream, to every record at the same time, and it has to be written down before the run that needs it, because there will be nobody there during the run to supply it.
So the thesis of this part is the one in the title. When nobody reads each output, the specification stops being documentation and becomes the thing that actually operates the system, with the decision log as its memory. Everything below is about what went into those two files, in what order, and what happened when they turned out to be wrong.
Ten principles, written before the spike was judged
The Ledger’s specification began as a project document for a Cowork project, and its third section lists ten principles. They were finished on 24 September, in version 0.3 of the document, the day before the feasibility spike was judged. The document marks its first three sections as stable, with a sentence I wrote for my future self as much as for the model: they “change only with the owner’s explicit approval”. Everything from the data model onwards is allowed to evolve, and has.
Not all ten turned out to carry equal weight. “Every fact has a source” and “GA is the default” are close to definitions of the product. Four others did something more interesting, which was to settle arguments weeks after they were written, often arguments I had not foreseen.
The first is principle 6, which the launch article already quotes and which shaped the pipeline: “Deterministic where possible, LLM where necessary. Fetching, normalisation, deduplication and validation are scripts. The model extracts and classifies within a fixed schema and taxonomy.” Every time a new problem appeared, a date that went backwards, two states on the same day, a “coming soon” item read as shipped, this principle decided where the fix belonged. The answer was almost always a validation rule, and almost never a better instruction, which is the same conclusion Part 2 reached with a 248-line script, here written down before the failure instead of after it.
The second is principle 4: ""Not detected” is not “absent”. The site never claims a product lacks a capability; it states it has not detected it, and shows source coverage per product.” This one governed far more of the interface than I expected. When an external review looked at the empty cells of the Release Matrix, the principle had already answered the question it raised: the record has no capability inventory, so an empty cell gets no baseline mark, only an explanation of absence and a link to the Methodology.
The third is principle 8, the shortest: “Schema before pixels. No frontend work until schema, taxonomy and baseline are validated.” It is the one I was most tempted to break, because a site you can click on is much more persuasive, to yourself above all, than a JSON Schema. Holding to it meant that when the site work began, every page was rendering a data model that had already survived a spike and a taxonomy freeze, and the front-end decisions in the log are all about how a record is presented, because what a record is had been settled first.
The fourth is principle 10: “Protect the machinery, not the facts. Facts, dates, states, sources, methodology and corrections are public. Operational internals (raw text, extraction artefacts, confidence scores, resolution history, QA data, run logs) are private. No moat is built on secrecy of the facts.” It decided, for instance, that the model’s confidence scores stay private while each state publishes the type of source behind it, because a published confidence number would suggest a precision the process does not have.
None of these principles is clever. What made them useful is that they existed before the first argument about any of them, which meant that later decisions could cite them, and no session had to make them up from scratch on the day.
The spike that rewrote the architecture
The specification had a clear plan for where the judgement would run. GitHub Actions would do everything mechanical, and Cowork scheduled tasks would do only the work that needs reading comprehension, extraction, resolution and classification, with the right to open pull requests on the data repository as their only credential. It also had a fallback written into the same section: if Cowork scheduled tasks proved unreliable for a daily flow, the judgement stages would move to GitHub Actions calling Claude, and “nothing else changes”. And it listed, as the first thing to verify before anything else, whether a scheduled task could open pull requests at all.
It could not, at least not in the way the plan assumed. The go/no-go note of 25 September records that Cowork’s cloud sandbox could run git push but could not call the GitHub API, which is what opening a pull request requires. The note still recommends going ahead, on technical feasibility, with a changed route. The extraction job runs in GitHub Actions through claude-code-action, with its tools limited to reading and writing files. It pushes only to branches named ingest/*, using a fine-grained token with permission on repository contents and nothing else. A separate workflow validates each branch, opens the pull request and merges it only if every check passes. The required check is enforced by a ruleset on main, and the workflow files are owner-only by design, so the token the job holds cannot change the rules that judge it. Cowork stayed where the owner and the model design, review and fix things, and stopped being the daily runner.

That is the extent of what I will say about the credentials here. Who an agent acts as and what it is allowed to do in that role are the questions the next series takes on properly, and a single job on a personal account is a thin case to generalise from.
The spike also priced the work. On real Braze and Adobe Journey Optimizer release pages, extraction cost between about 0.30 and 1.15 USD per page at API-equivalent prices, dense Adobe pages costing roughly three times as much as Braze, which works out at 0.014 to 0.018 USD per feature. It runs on my subscription allowance and is not billed separately, so the number that matters in practice is whether the allowance holds under daily load, which the note lists as something to watch for two weeks before the backfill.
The line in the note I return to most is in the safety row: “prompt injection in a source page ignored”. It sits next to “direct push to main rejected”, “invalid data blocked from merging” and “only data/ is ever committed”, and I want to be honest about its weight. One ignored injection in a spike is evidence of one test. What makes me comfortable is the rest of the row, because the specification never relied on the model resisting instructions. It says that text from fetched pages “is data, never instructions”, that the jobs write only data files and never publish free text as-is, and that anything failing the schema or citing a domain outside the allowlist is rejected before it can merge. A successful injection would have to produce valid data that passes every rule, which is a much smaller target than a model that can be talked into something.
A taxonomy frozen, then versioned six times in eight days
Every record on the Ledger carries a capability from a fixed taxonomy, and the specification is strict about how it changes. The model may propose a new capability into a queue, I approve or reject it, and an accepted change is applied with a version bump and a migration note. The model never classifies into something that does not exist yet.
The proposal in the specification had 14 areas and 50 capabilities. On 25 September, after the spike data had been migrated against it, I froze version 1.0 with 15 areas and 68 capabilities, including a new area for loyalty and offers and a rule that partnerships, rebrands and packaging changes are signals and never features. Then real extraction started on more platforms, and the taxonomy moved faster than I had planned. Version 1.1 arrived on 28 September, versions 1.2, 1.3 and 1.4 all on 29 September, and versions 1.5 and 1.6 on 2 October, which left it at 16 areas and 81 capabilities. Six versions in eight days, and then nothing: on 14 November it was still at 1.6.
What made that pace safe was the freeze itself. Each version was a complete, numbered state with its reclassifications listed, so a record classified under 1.2 could be traced, and Hightouch could be re-extracted when the rules changed under it, which happened once.
That change is the one I consider the most important in the taxonomy’s history, and what it did was remove a restriction. Each capability carries an applies_to field saying which categories it belongs to. Until version 1.2 the validator treated that field as a constraint, so a CDP feature could only take a CDP capability. Hightouch and Treasure AI kept shipping journeys, editors, experiments and coupons, and 12 Hightouch features had been forced into CDP-only capabilities that did not describe them. Version 1.2 made applies_to informative, a statement of where a capability typically appears, and let any product use any capability, chosen by what the feature does. The decision log records the consequence in one line: it “makes the CDP-to-CEP convergence visible in the data”. A rule meant to keep the taxonomy tidy had been hiding the most interesting movement in the market, and I would not have seen it if I had kept reviewing records one at a time.

The rejections taught me as much as the additions. Version 1.1 refused capabilities for unified navigation and for homepage or command-centre surfaces, because generic interface changes would attract every redesign a vendor ships, and the extraction prompt now tells the model not to propose them. A unified calendar is classified by what it does, which is cross-channel orchestration. And version 1.4 records a rejection that produced no version at all: edge or on-device AI inference, proposed from a single Tealium feature, was classified under predictive models with a note to revisit if other vendors ship it. A taxonomy that accepts every proposal stops being a taxonomy, and writing down the refusals with their reasons is what keeps the model from proposing the same thing again next week.
The decision log is the memory
When the specification was written, I expected it to remain the reference for the project. It did not, and the first day showed why. The first entry in the decision log, dated 25 September, adopts a different phase numbering and notes “Spec §19 to be aligned”. The second promotes the specification’s own fallback to the primary architecture. On 4 November I reread the specification for this article, and section 8 still describes Cowork scheduled tasks doing the judgement work. The specification is the founding document and still holds the principles, but the current truth lives in the log.
By 4 November the log held 83 decisions, the first on 25 September and the latest on 4 November, which is 41 days. Each row has a date, an identifier, the decision and its consequences, usually with the pull request that implemented it. The busiest day was 29 September, with eleven, the day three taxonomy versions were frozen and the site’s structure was laid down. Several rows were superseded, and every one of them is still there. The label required by Article 50 of the AI Act changed placement twice on 23 October: first on every page, then in the footer only, then back on the pages with a link to a new page explaining how AI is used, and all three rows survive in order. Minor updates on the home page went from hidden by default to shown by default five days after the first decision. “Feed” became “Timeline” on 17 October, with the reason written next to it. On 16 October a reclassification of a Treasure AI feature reversed a confirmation made in an audit eight days earlier, and the row says so.
Leaving superseded decisions visible is the same point I made about memory in Part 1, from the other side. A note that was true in June and is wrong in October is dangerous because it speaks in the same tone as a correct one. A superseded decision that says what replaced it, and when, is harmless, because the next session reads the whole sequence and lands on the current state with the history attached. Deleting the old row would make the log shorter and the reasoning behind the current rule invisible.
The other half of the discipline is one sentence in the project’s instructions file, which every session reads first: read the decision log before any structural change, and “do not reopen a recorded decision without a concrete reason”. A collaborator that remembers nothing will otherwise relitigate everything, with the best intentions, every time a problem looks like one it has never seen. The most recent entries show what that rule looks like when it works. On 4 November an A/B test of a different extraction setup cut turns by 69% and cost by 29% with equal recall, and the decision was not to adopt it, because quota and Actions minutes were well within the plan and the capability match was slightly worse on a small sample. The row then says exactly when to reopen it: when Actions usage passes about 1,600 minutes a month or the quota gets tight, and only after rerunning the comparison on a larger batch. That is a decision that knows its own expiry date.

What transfers to a client architecture
The Ledger is one person’s side project with one owner, no approval chain and a regulatory label I chose to apply myself. Most of what makes enterprise agentic work hard is absent from it, and I said in Part 1 which of those absences matter. Two things from it do transfer, and both are older than agents.
The first is “schema before pixels”, which on a client project reads as schema before journeys. Every CDP implementation I have worked on has had a moment, usually early and usually under pressure, when somebody wants to see a journey running before the profile model, the identity rules and the consent attributes are settled. The journey is persuasive in exactly the way a clickable site is persuasive. The cost arrives later, when the journey turns out to depend on an attribute nobody defined, or on an identity rule that changes underneath it, and every running journey has to be revisited at once. I have argued for the order before in the CDP and CEP architecture patterns, and the Ledger gave me a version of that argument I had lived through myself: the data model was frozen, versioned and migrated before a single page rendered it, and each of the six taxonomy versions cost no more than a reclassification.
The second is the decision log, and it matters more as agents take on work that used to need a person in the room. A marketing operation that lets an agent build segments or adjust journeys overnight is running exactly the system this article describes, one where nobody reads each output before it reaches a customer. The rules that agent follows need to exist before the run, stated somewhere it actually reads, with superseded rules kept visible and a declared condition for reopening each one. Most organisations I work with keep these decisions in slide decks and meeting notes, which is fine while a human applies them and useless the day something without a memory has to.
Vendors do not demo either of them, and yet they are the documents that decide whether what the vendor demoed is still behaving the way you agreed it should on a morning when nobody is watching.
When nobody reviews each output, the rules you wrote down before the run are the only operator the system has, so write the spec as if it will run the system without you.
Sources
MarTech Ledger
- Methodology. Sources and their cadence, validation rules, the meaning of absence and the statement that there is no per-record human verification.
- How AI is used. What the model does in the pipeline and what it does not do.
- Taxonomy. The current capabilities and areas, the classification rules and the version history.
- Corrections. The public register of changes to published facts.
- About MarTech Ledger. Scope, the meaning of Beta and the author’s disclosure.
Tools and regulation
- Claude Code GitHub Actions. The GitHub Action that runs the extraction step.
- GitHub, About rulesets. The mechanism that enforces the required validation check on the main branch.
- The EU AI Act’s transparency rules: a practical guide to Article 50. The labelling obligations behind the AI-generated label.