Issue Vol. 1, № 04 Updated May 2026 Corpus 15 runs · 4 published

A research log — Closed beta · 15 runs documented · In flight

Antacog

Antacog is an experimental project in agentic governance, built around an AI agent called Ant. Ant sits upstream of execution agents.

Dialogue becomes substrate. Substrate commissions work. Agent output returns as a claim.

context · scope · authority output · evidence · rationale Engagement Claim dialogue You Ant i domain model ii decisions iii evidence iv authority check ANT GOVERNS ← escalate ↑ consolidate redirect → Agent any kind you bring
Hover or tap any element above — User, an arc, the substrate, the check, or an outcome — to see what it is, what it carries, or what it does.
Fig. 1 — The Ant Loop. You never speak to an agent directly. Antacog doesn't ship agents — it governs whatever you bring.

You don't hand raw intent directly to coding, research, or operations agents. You first work with Ant to unpack the work into a grounded substrate — domain model, goals, constraints, assumptions, decisions, evidence, open questions, and authority boundaries.

That grounded substrate becomes the interface to agents.

Ant commissions bounded work from agents — coding, research, analysis, design, testing, documentation, or operational planning. The handoff is not just a prompt. It is a governed work order with context, scope, authority, evidence requirements, and escalation triggers.

Agents execute. Ant governs.

When agents return output, Ant treats it as a claim, not truth. It checks provenance, evidence, rationale, assumptions, authority boundaries, and impact on the existing model. If the claim fits, Ant consolidates it. If it conflicts, Ant redirects, asks for evidence, marks a gap, or escalates to you.

The research question is whether this gives subject-matter experts a scalable way to direct agent teams without becoming prompt engineers or technical managers.

Current IRATA Level 3 Boilermaker and former Team Leader at an NGO youth re-engagement program. I've worked in environments where governance, risk, and accountability have real consequences. That shapes this work.
Core principles
i.

Grounded reasoning beats ungrounded action.

Traceable provenance matters. Every claim should be traceable back to the dialogue, evidence, or decision that produced it. I believe this produces more reliable outcomes in human thinking, and I'm testing whether the same holds for autonomous agents. The work here is whether that belief survives contact with reality.

ii.

The conversation is the artifact.

What's load-bearing isn't the final model. It's the argument that produced it — what was challenged, what was conceded, and what wasn't worth pulling on. The dialogue is the primary record. The model is the residue.

iii.

Friction is epistemically valuable.

Tools that optimise for agreement create artifacts that don't survive pressure. Tools that support productive challenge create artifacts that do. This work is built around the second.

Findings — seven
Snapshots — detail on request
№ 12 June 2026 Run 19
№ 12 June 2026 Run 19

The template path routes around the LLM and the 855 files it already holds.

Expected the whole_repo run to produce premise substrate specific to Antacog's actual auth implementation. What scaffolded: the five template premise nodes verbatim, the five relationship descriptions word-for-word from the YAML, 16 evidence pointers attached via path-existence check (not content read). Ant's opening turn was fluent over the template's shape with zero contact with the actual invite-only, multi-tenant code sitting in the ingest. The two failures are the same failure: the template stamps a generic shape and asks canned questions instead of letting Ant read what it's already holding. The inverted epistemic frame cuts deeper than a missing grounding step: this auth code is implemented and working. Bootstrap marked it exploring / assumed and emitted canned questions about a passwords_controller.rb it was holding. Dialogue is rightly speculative because the future isn't written. Bootstrap is running against code that exists. The template makes the wrong epistemic call by default, and the call compounds: it routes intelligence around the files, so no subsequent step corrects it.

Request more information →
№ 09 May 2026 Run 17
№ 09 May 2026 Run 17

Bootstrap and dialogue share a model but produce two different ontologies of substrate.

Pre-registered that code-only INTERPRET would produce substrate comparable to the dialogue baseline — or establish that history ingest is dead weight. Verdict: (b) DIVERGENT, headline ratio 2.90. The divergence isn't "less" — it's differently shaped. Bootstrap produced 525 elements to dialogue's 24; decisions = 0, relationships = 0 from code-only. The 525 are file atoms, one row per source file. The 24 are conceptual abstractions. Same DB model, different ontologies, no current path between them. The radical bet hypothesis survives — but only because the experiment revealed it was asking the wrong question, not because the numbers matched.

Request more information →
№ 08 May 2026 Run 16
№ 08 May 2026 Run 16

The acceptance test that defines B13 completeness had never been run.

B13 was marked complete. The rake task had RSpecs. The pre-flight memo named five failure modes. None of the three blocking bugs — a predicate name mismatch in the rake task, an OAuth button that fails silently in two independent ways, a paginator that bypasses token-refresh so long-running jobs expire mid-way — appeared until the first end-to-end run against a real target. The run crashed mid-HistoryIngest after 135 minutes. No substrate was built on the candidate sibling. No verdict. All three bugs were in code paths that had shipped but had never been exercised in this configuration. The acceptance test that defines completeness ran for the first time today, and it didn't pass.

Request more information →
№ 03 May 2026 Runs 9, 12, 13, 14
№ 03 May 2026 Runs 9, 12, 13, 14

Grounding laundering: when transcription substitutes for independent grounding.

Across four runs at structurally different surfaces — librarian summaries, spec writebacks, inferred substrate — the loop substituted summary-of-source for independent verification. The pattern transferred across domains and produced a named diagnostic — current accident, not current contract — now load-bearing in the methodology.

Request more information →
№ 02 May 2026 Run 14, labelling probe
№ 02 May 2026 Run 14, labelling probe

Mode 1 emerged from labelling, not specification.

The behavioural mode embedded in the loop wasn't designed up front. It was named retroactively from a false-positive labelling probe across the run corpus. The methodology generated the spec; the spec didn't generate the methodology — a sequencing claim with consequences for how later modes get added.

Request more information →
№ 01 May 2026 Run 12, external transfer
№ 01 May 2026 Run 12, external transfer

The loop caught a structural defect on a codebase separate from Antacog's own.

Running autonomous-trigger against infieldOS — an in-house project of mine, separate from Antacog — the loop recognised that an append-only constraint tracked as a convention should be enforced at the registry level. Convention upgraded to structural rule — the transferability claim earned its first concrete artifact outside the loop's own corpus.

Request more information →
Open question under investigation

When the loop scales from one agent to two or more, how does Antacog prevent agents from contradicting each other against the same grounded model?

Is Antacog the coordination layer, or just the grounding layer?

Antacog Run 5 · Q13 Take this up →
Methodology

The loop is documented separately — run corpus, substrate model, and the dogfooding pattern that produces the findings above. Methodology notes are available on request alongside closed-beta access.

Access

Antacog is in closed beta. Operators are invited; the run corpus is private. The dialogue product is the surface where the work above is generated and tested.

Request access →