Skip to main content

DOSSIER II · Compilers, Kernels & Verifiable Proof (Entry 01 of 06)

The AI Dev Tools I Built in 2026: 58 Builds, Five Shifts

Trace 58 AI dev tools I built across 70 workspaces in 2026 — from early agent loops to DXP ontologies, fleet worktrees, FinOps gateways, and signed proof.

14 min read

By Dakota Smith

Share article

XLinkedIn
On this page8 parts

Architectural scope

Complete architectural ledger of 58 active builds across 70 public, private, and local workspaces from January through November 2026.

Cadence
14 min read
Structure
8 sections · 2 code specimens

Between January and November 2026, I built 58 active AI dev tools and engineering prototypes across 70 repositories and local workspaces. That total spans 22 public GitHub repositories, 39 private repositories, and 9 local delivery workspaces, after excluding 12 personal utilities, starter forks, and unpopulated stubs. In January, I wanted one autonomous loop to clear a feature backlog while I slept. By November, I was building Rust worktree supervisors, 617-record platform ontologies, multi-model FinOps gateways, and control planes that block promotion without cryptographic proof.

Most commercial AI dev tools optimize for TokenA chunk of text — roughly three-quarters of a word. The unit the model reads and bills in.The fragments a model breaks text into. Around 100 tokens ≈ 75 English words. Limits and pricing are counted in tokens, not words or characters.Full definition speed inside one editor tab. Raw code generation stopped being my bottleneck in week two. Each month of real enterprise and personal delivery exposed the next failure mode one ring outward: swarm coordination noise, platform blindness, evaporating session state, drifting configs, and unverified release authority.01 · Portfolio ScopeThe 70 audited workspaces split into 58 engineering builds and 12 excluded personal apps, vendor starters, and empty git stubs.

Here is the full 2026 engineering ledger across five architectural shifts, including the private control planes and domain engines alongside the open-source releases, what stalled, and when custom tooling is the wrong trade.

Five Shifts Across 58 AI Dev Tools

Sorting commit histories and local workspace timestamps from January through November reveals five distinct architectural waves. Every wave started because the previous layer worked well enough in daily delivery to expose a deeper structural failure.

WaveWindowCore QuestionRepresentative Public & Private BuildsWhat Broke Next?
1 · Loops and SwarmsJan – Feb 1Can an AgentA worker you delegate to: brief it, and it takes steps on its own. A chatbot answers; an agent acts.An LLM that runs tools in a loop toward a goal — it acts, checks the result, decides the next step, and repeats until done.Full definition loop ship a coherent codebase?claude-marketplace, agentctl, apl, dxpulse, ORC, ALLOY, handoffkit.ai, replayops, studio.Agents lacked enterprise platform rules, ADR memory, and Day-2 ops discipline.
2 · Domain MCPUSB-C for AI — one standard plug so any agent can connect to any data source or tool.The Model Context Protocol: an open standard (Anthropic, 2024) for connecting AI systems to external tools and data without building a custom integration for each one.Full definition & OntologiesFeb 4 – MayHow do you ground agents in real enterprise estates?conduit, dxp-cortext, hive, plugin-hive, plugin-architect, plugin-gtm, plugin-ops, plugin-migration-planner, plugin-cms-toolkit, starter-template, umbraco-upgrade, 127-skill consulting catalog, dxh, Agent-C.Terminal sessions still wiped workflow state, account history, and worktree isolation.
3 · Durable State & Fleet WorktreesMar – AugWhere do memory, worktrees, and routing live across runs?azure-devops-claude-auto-pr, Managed Plugin Pipeline, Deep-Research Verifier, SharePoint OKF Builder, dossier, sleuth, rezident, 45-repo Sitecore XM 10.4 team HarnessThe cockpit around the engine. The model is the engine; the harness is everything that makes it useful and safe to fly.The runtime around the model — the loop, tool access, memory, prompts, and guardrails. The model reasons; the harness does everything else.Full definition, Board Assurance Pipeline.Hand-edited skills, cross-harness instructions, and CMS trees drifted across repos.
4 · Compilers, Ontologies & GatewaysJun 25 – NovWhat if configs, platform facts, and routing are deterministic?objectcore, objectcore.ai, skillsmith, base, treesmith, rootsmith, directed-motion, dxp-kb, dxpwise, aether, dsh-factory.Deterministic inputs still could not authorize an agent's output in client production.
5 · Delivery Authority & ProofJul – NovWho holds authority to verify and accept agent change?delivery-harness (5-binary daemon), sa-steward, Steward, dxctl, dxctrl, sprint, coform, handoffkit, dak, idkt, directed-assembly, Proof, proof-migrate, proof-platform, practice.Active frontier: progressive ceremony from 60-second local sandboxes to tenant stamps.
PLATE 01CONTROL BOUNDARY STACK
REV 2026.11 // 58 ACTIVE BUILDS

Deterministic Rings Around the Probabilistic Loop

Five concentric architectural layers surrounding the probabilistic model loop: runtime supervision and worktrees, protocol and domain knowledge boundaries, configuration and catalog compilers, two-speed gateway and sandboxes, and exact-candidate delivery authority with cryptographic proof.

PROBABILISTIC REASONING CORE

Claude Code · Codex · Gemini Interactions (bounded turn execution)

  1. 01

    Runtime Supervision & Durable Worktrees

    Confidence gates, Git worktree isolation, zero-transcript JSONL ledgers

    APL · studio · rezident · MISEv2
  2. 02

    Protocol & Domain Knowledge Boundaries

    Read-only MCP inspection, 617-record DXP ontology, ADR drift & GUID kernels

    dxp-cortext · dxp-kb · dxpwise · hive · treesmith
  3. 03

    Configuration & Catalog Compilers

    Hand-edited sources -> byte-locked multi-harness rules, skills, and registries

    base · skillsmith · objectcore · dossier
  4. 04

    Two-Speed Gateway, FinOps & Isolation Sandboxes

    Sub-250ms pre-flight classification, token FinOps, V8 WASI & Windows HCS

    dsh-factory · Steward · dxh
  5. 05

    Exact-Candidate Authority & Signed Proof

    Commit-SHA DoD, maker/checker separation, Ed25519 & BLAKE3 evidence bundles

    delivery-harness · dxctrl · sa-steward · Proof · proof-platform
PLATE 01: Across 58 engineering builds in 2026, every durable gain came from moving state, domain rules, compilation, routing, and acceptance out of the prompt and into deterministic rings around the model.

Shift 1: Loop Wrappers and the Swarm Trap

January started on familiar ground. Fourteen years in enterprise .NET and digital experience architecture pushed me to encode static codebase diagnostics first in my CMS analysis plugin marketplace (claude-marketplace, Jan 10). Static audits worked immediately, so two weeks later I chased autonomous execution.

agentctl (Jan 24) wrapped claude-code, aider, codex, and amp in a Makefile and shell loop where every turn started with clean context and deterministic exit checks. One day later, APL, the Autonomous Phased Looper (apl, Jan 25), split execution into Plan, Execute, and Review phases backed by persistent .apl/ pattern memory. APL built the initial version of this blog across 47 stories and 6 epics, then scaffolded dxpulse (Jan 28) as a Next.js and tRPC testbed.

Early momentum triggered an overcorrection. On January 30, I initialized three repositories in a single day: ORC ("One PromptThe brief. Closer to writing instructions for a new contractor than to programming.The text you give the model — question, instructions, context. Its quality shapes the quality of the output.Full definition. Nineteen agents."), handoffkit.ai, and replayops. ORC delivered the sharpest negative result of Q1: nineteen specialist prompts created nineteen competing architectural opinions, heavy token burn, and worse code than three tight roles. An internal follow-up (ALLOY) tried letting three core agents summon specialists optionally, proving a second hard rule — models skip optional quality gates whenever completion pressure rises.

STUDIO (studio, Feb 1) closed Wave 1 by cutting back to three agents and making supervision non-negotiable. Execution blocked until a pre-plan questioning pass cleared an explicit confidence threshold, every step ran a shell verification gate, and operator corrections persisted to disk.

Shift 2: Domain MCPs, ADR Vaults, and Enterprise Catalogs

Supervising the loop exposed the next gap: coding agents hallucinate deprecated APIs and break enterprise platform invariants when they lack structured domain context. February shifted focus from loop mechanics to Model Context Protocol boundaries and practice-wide packaging.

On the protocol side, conduit (Feb 4) prototyped a unified TypeScript MCP layer across headless CMS platforms, and dxp-cortext (@twofold/dxp-cortex, Feb 8) narrowed that surface for Sitecore, Umbraco, and Optimizely. dxp-cortext served platform guardrails alongside strictly read-only live inspection. Removing create, update, delete, and publish tools from the MCP schema eliminated live content corruption by construction.

One week later, I built two distinct systems sharing a similar name. Public plugin-hive (Feb 15) tested a Node 22 node:sqlite worker swarm, while private hive (Feb 15) became a 46-tool, 10-category SQLite MCP vault (~/.hive/hive.db) with five interactive UI views. hive logged Architectural Decision Records, cached real dependency API signatures, and flagged cross-project drift so coding agents stopped inventing method names across client codebases.

terminal — read-only DXP inspection + lifecycle gates
# Serve platform rules and strictly read-only CMS inspection over MCP
npx @twofold/dxp-cortex
 
# Run deterministic health and release runbook checks across a plugin repo
npx @twofold/plugin-ops check --min-score 80

Building plugin-hive also showed that authors of internal AI dev tools needed extension boundary rules more than another swarm. That insight produced a three-repo lifecycle trilogy: Plugin Architect (plugin-architect), Plugin GTM (plugin-gtm, 29 MCP tools), and Plugin Ops (plugin-ops, 32 MCP tools). Those tools immediately fed enterprise delivery assets.

  • Multi-platform delivery plugins. plugin-migration-planner (Feb 20) structured AWS-to-Azure Sitecore XP discovery and estimation, while plugin-cms-toolkit (Feb 21) added multi-CMS scaffolding and OWASP/CVE checks. starter-template (Feb 25) locked in a golden Turborepo, Next.js, Bun, and Drizzle baseline, and umbraco-upgrade (Feb 27) ran Umbraco 15-to-17 LTS upgrades in Skills or Agent Mode.
  • 127-skill consulting catalog & web storefront. For an anonymized enterprise consultancy, I packaged 127 role-scoped skills across 8 capability groups and 30+ roles. Workflows spanned discovery synthesis, SOW and RFP generation, blended-rate margin calculators, C4 architecture proposals, and QA matrices, all browsable through a 49-component Astro and Starlight internal storefront.
  • Zero-leak assessment & cited RAGLetting it check the notes before answering, instead of going from memory.Retrieval-Augmented Generation: fetch relevant documents at question time and have the model answer from them. It reduces made-up answers — it does not eliminate them.Full definition. Private dxh built a Bun and TypeScript DXP assessment harness emitting SHA-256-digested diagnostic reports without copying raw client source code. Private Agent-C paired URL-cited BM25 retrieval with supervised fine-tuning dataset pipelines.

Shift 3: Durable State, Worktree Fleets, and Team Harnesses

Spring exposed what stateless CLI AI dev tools miss. Laptop lids close, context windows compact, engineers rotate across accounts, and running five parallel agents on one working tree scrambles Git history.

azure-devops-claude-auto-pr (Mar 24) moved execution off my machine first, cloning repositories and opening draft pull requests whenever an Azure DevOps work item entered Active state. In June, two anonymized production systems separated control flow from model reasoning completely. My durable Managed Agents pipeline orchestrated four Claude Managed Agents through six deterministic Postgres-backed workflow stages, while my adversarial deep-research verifier paired a 97-call multi-agent verification fan-out with a 1-call daily SHA-1 monitor. A companion local 8-role extractor compiled Microsoft SharePoint and account intelligence via M365 MCP into validated Open Knowledge Format (OKF) bundles for dossier (Jun 13) and sleuth (Jun 25).

Three private and internal systems carried durable state into daily multi-engineer and multi-worktree operations.02 · Zero-Scrape Ledgersrezident logs bounded work, attention, and review events to append-only JSONL without scraping raw prompts, keeping client secrets out of telemetry.

  • rezident (Rust fleet control plane). Built in Rust (rez CLI plus native desktop cockpit over tmux and Windows Herdr), rezident maps each work item to a dedicated Git branch, linked worktree, and managed shell that survives terminal restarts. An append-only JSONL ledger projects status into disposable SQLite without scraping sensitive transcripts, comparing diffs against an immutable start commit so one engineer supervises five to ten parallel worktrees safely.
  • 45-repository Sitecore XM 10.4 team harness. Deployed across an anonymized 45-repo, 30+-site global Sitecore XM 10.4 estate (Helix, Unicorn, Solr, Azure DevOps), this team harness shipped 24 specialist agents and 8 hard hooks. Three-layer zero-secret config (package/, PR-governed config/, OS-env-only env.json) powered /fde morning briefs over a local read-only ADO mirror through /implement, /smoke, /handoff, and /timesheet.
  • 7-stage Board Opportunity & Assurance Pipeline. A stage-gated governance DAG (/opportunity:run) enforced typed contracts, a deterministic $50 per-run hard cap, and dual-persona intake filtering. Proposals cleared dual-critic Governance and Commercial red-teaming with a cross-model-family judge, NIST AI 600-1 and ISO/IEC 42001 mappings, and a code-enforced human sign-off gate.

Shift 4: Compilers, Cited Ontologies, and Model Gateways

By midsummer, operating AI dev tools across Claude Code, Codex, Copilot, and Gemini exposed silent input rot. Hand-edited CLAUDE.md and AGENTS.md files diverged, skill descriptions lost trigger accuracy, and tribal upgrade estimates varied wildly depending on which architect scoped an engagement.

The fix was treating instructions, catalogs, domain facts, and model routing as deterministic compiled systems — the core thesis of compiling your agentic system.

  • Config and catalog compilers. ObjectCore (objectcore, Jun 25) derived SHA-pinned registries via a pure deriveCatalog(plugins, opts) pass with OIDC publishing and five eval layers, alongside objectcore.ai (Lighthouse 100 and WCAG AAA under 50KB of JS). skillsmith (skillsmith, Jul 10) enforced 14 quality gates, 7 security rules, and a 0.85 trigger hit-rate floor, while base (base, Jul 14) compiled one Rust canon into byte-locked Claude Code, Codex, and Copilot configs.
  • Domain kernels. treesmith (Jul 16) gave agents template-aware, GUID-safe Rust CLI and MCP operations over serialized Sitecore YAML trees. rootsmith (Jul 16) ran declarative drift control across multi-domain footprints, and directed-motion (Jul 20) compiled Markdown briefs into layout-checked Remotion 4 video specs.
  • dxp-kb & dxpwise (617-record DXP ontology). Private dxp-kb mapped 178 canonical DXP operations into 617 vendor-cited JSON records across 9 version tracks (Sitecore XM Cloud, XP 10.x, XP 9.x, Optimizely CMS 11/12, Umbraco 10–13 LTS, plus cross-major upgrade paths) and 81 agency staffing and cost-driver benchmarks. Every record enforced "no source, no record," queried via dxpwise's citation-locked BM25 CLI and web app, while aether prototyped a Rust (Axum, CockroachDB) and Svelte 5 headless DXP scoring SEO and ADA compliance live.
  • dsh-factory (Multi-model FinOps & Jev gateway). Six plugins routed Claude, ChatGPT, Gemini, DeepSeek, and OpenRouter through a zero-secret local gateway. It tracked lifetime provider cost (dsh-usage-hub), ran simultaneous N-model benchmarks (model-arena), and fired automated in-loop Jev quality judgments on tool outputs.
dxp-kb/schema/operation-record.ts
// "No source, no record" — sourceless claims fail PR validation at merge time
export interface CanonicalDxpRecord {
  operationId: `OP-${'MIG' | 'UPG' | 'SEC' | 'OPS'}-${string}`;
  track: 'sitecore/xm-cloud' | 'sitecore/xp-10.x' | 'optimizely/cms-12' | 'umbraco/13-lts';
  vendorCitations: readonly [HttpUrl, ...HttpUrl[]];
  procedureSteps: readonly string[];
  failureModes: readonly string[];
  effortFactors: readonly { driver: string; multiplier: number }[];
}

Shift 5: Delivery Authority, Containment, and Signed Proof

Compiling inputs and citing vendor docs still left the hardest enterprise question open: who has authority to accept an agent's work into a regulated client system? Three models agreeing a diff looks clean is still probabilistic consensus, not engineering assurance.

From July through November, twelve private and public AI dev tools converged on exact-candidate delivery authority.03 · Proof of DoneIn dxctrl and delivery-harness, verification binds to the exact candidate commit SHA, and an inconclusive check blocks promotion identically to a hard failure.

  • 5-binary delivery-harness daemon. Split runtime loops from acceptance across five binaries (dh, delivery-harnessd, supervisor, mcp, runtime-host), governing Claude Code, Codex, and Copilot behind signed human plan approval, daemon-executed red/green checks, and hash-chained journals.
  • sa-steward & Steward (Zero-execution graphs & HCS isolation). sa-steward admitted legacy Sitecore XP 10.4 estates without executing untrusted client code — extracting Helix, MVC, and Unicorn graphs into immutable SQLite generations alongside signed TeamCity build assurance and SHA-256-locked .steward/system/ packs. Companion Steward ran Sitecore 10 XM inside privileged Windows Host Compute System (ComputeStorage.dll) containers with none network isolation and per-client vaults.
  • dxctrl & dxctl (DXP agency control planes). Local dxctl introduced reversible dxctl cs revert GraphQL changesets and dxctl gym graded evals for Sitecore XM Cloud. Private dxctrl (a hardened T3 Code fork on Node 26) built a five-pillar control plane across Sitecore, Umbraco, and Optimizely. It enforced commit-SHA Proof of Done where inconclusive blocks like fail, CMS item-tree serialization diffs with shared Content Management environment leases, hierarchical Agency -> Client -> Engagement -> Project policy narrowing, and Client AI-Usage Disclosure Ledgers.
  • Consulting SDLC workspaces (sprint, coform, handoffkit, dak, idkt). sprint wired work-graph parallel dispatch, structural maker/checker separation, runtime filesystem allowlists, and sprint retro rule pruning directly into Azure DevOps and Jira. coform isolated per-client workspaces (Hocuspocus, Temporal, Postgres, agent worktrees) behind four delivery gates separating requirements consent, execution allowances, build verification, and customer acceptance. Private handoffkit (Next.js 16 and Trigger.dev) compiled 8-section branded PDF project handoffs in under three minutes, while dak (JSON-LD constitutional runtime) and idkt (WebAuthn + RFC 9180 HPKE E2EE working room) hardened identity and consent.
  • Cryptographic proof kernels (directed-assembly, Proof, proof-migrate, proof-platform, practice). Public directed-assembly (Aug 15) demonstrated local capability planning across Registry, Policy, and Relay adapters. Three Rust repositories then pushed acceptance into offline-verifiable cryptography. Proof (Aug 3) issued per-agent Ed25519 keys and AuthorityEvidenceBundleV1 exports; proof-migrate (Aug 20) verified Sitecore migrations via RFC 8785 canonical JSON and domain-separated BLAKE3 commitments; and proof-platform (Aug 28) signed AXP operation proofs, followed by practice (Aug 31), an open Git library of field-tested AI methods.

Graveyard, Consolidations, and When Not to Build

Fifty-eight engineering builds across ten months only make sense if you are blunt about what died, what consolidated, and what carries a steep maintenance tax.

Empty stubs and retired stepping stones. Four public repositories (manifest, Genesis, Assembly, sitecore-orchestration-blueprint) plus internal placeholders stalled right after git init because the underlying contracts were not earned yet. Early stepping stones — agentctl, ORC, ALLOY, dxpulse, public handoffkit.ai, replayops, and plugin-hive — are retired; their working seams were absorbed into base, rezident, handoffkit, and dxctrl. Even the late-2026 systems enforce strict scope fences: proof-migrate runs strictly offline against exports rather than live CMS APIs, dxctrl targets M2 pack conformance prior to Apache-2.0 release, and proof-platform's operator plane remains pre-1.0.

Repository sprawl is a real tax. Operating dozens of specialized PoCs taught me why production organizations must consolidate into coarse horizontal planes rather than spawning a new repo per vertical workflow. Do not build custom compilers, Rust worktree daemons, DXP ontologies, or cryptographic proof kernels if your team works in one repository on a single coding harness where AGENTS.md, native hooks, fast CI tests, and standard pull-request review already catch regressions. Build these control layers only when multi-harness drift, shared enterprise environments, or regulated client assurance make chat-bound trust unacceptable.

Conclusion

Building 58 AI dev tools across 2026 taught me the same lesson at five ascending scales. Keep probabilistic reasoning inside a tight turn loop, and surround it with deterministic supervision, cited domain ontologies, byte-locked compilers, isolated worktrees, and cryptographic acceptance gates. Every jump in frontier model capability between January and November made those deterministic outer rings more valuable, never obsolete.

Key Takeaways:

  • Supervision and isolation beat swarm size. Three gated roles (studio) and isolated Git worktrees with zero-scrape JSONL ledgers (rezident) outperform nineteen uncoordinated specialist prompts (ORC).
  • Ground enterprise work in cited, read-only boundaries. Read-only MCP servers (dxp-cortext), zero-execution static graphs (sa-steward), and source-locked ontologies (dxp-kb's 617 records) stop hallucinations and live mutations before they happen.
  • Compile shared state and measure model economics. Generate multi-harness configs and registries (base, skillsmith, objectcore) deterministically, and track multi-provider cost and quality in the loop (dsh-factory).
  • Bind acceptance to exact candidates and human sign-off. Treat inconclusive checks as failures, separate maker and checker sessions, and seal Proof of Done bundles (delivery-harness, dxctrl, Proof) tied to immutable commit SHAs.
  • Consolidate after prototyping. Use narrow PoCs to discover real seams, then fold proven capabilities into a small number of horizontal platform services rather than maintaining fifty micro-repos.

Public repositories from this ledger live on my GitHub profile, and curated system breakdowns live on /work. To study the architecture underneath these builds, explore the Harness Engineering and AI Security pillars here on daksmith.dev.

DOSSIER II · ENTRY 01 OF 06

Compilers, Kernels & Verifiable Proof

Replacing hand-patched prompts and chat-bound trust with deterministic compilers, domain kernels, and signed candidate acceptance.

Harness Engineering Pillar
  1. 01The AI Dev Tools I Built in 2026: 58 Builds, Five ShiftsReading now
  2. 02Compile Your Agentic System: base, skillsmith, and ObjectCore8 min read
  3. 03The Agent Delivery Harness: An Opinionated Multi-Model Layer14 min read
  4. 04Compiling Agent Config to Claude Code, Codex, and Copilot7 min read
  5. 05Quality Gates for Claude Code Skills: Inside skillsmith8 min read
  6. 06ObjectCore Deep Dive: A Plugin Marketplace as a Software Factory7 min read

Further analysis

Selected by shared architectural signals and recent publication history.

  1. 01AI9 min read

    Agentic Engineering: From Solo Copilots to Governed Fleets

    Trace the four-stage shift to agentic engineering — from IDE chat to durable worktree fleets, a five-plane foundry, and exact-candidate delivery authority.

  2. 02AI10 min read

    An AI Governance Framework in Code, Not Slide Decks

    Build an AI governance framework in code: a 15-module NIST PR spine, Cedar policy narrowing, sub-250ms pre-flight guards, and a 7-stage board assurance DAG.

  3. 03AI14 min read

    The Agent Delivery Harness: An Opinionated Multi-Model Layer

    An agent delivery harness turns human intent, experience, and judgment into accountable, evidence-bound decisions across one or more model runtimes.

Discussion

Loading comments...