video youtu.be Watch ↗

The Agentic Engineering Meta

TL;DR

Frontier models are already good enough for the tasks you throw at them, so the binding constraint has moved off model capability and onto the harness — context engineering and consistency — especially across teams. Jaymin West's "meta" is three provider- and harness-agnostic pillars that make agents reliable: agent rituals (fixed begin/middle/end steps declared in CLAUDE.md/AGENTS.md so every agent behaves the same way), a context substrate (an agent-first, structured — not markdown — queryable memory layer anchored to code sections, that agents prime before work and record learnings into; demoed as the mulch CLI), and planning (spend ~90% of attention up front; plan → decompose → validate → repeat; break work into atomic tasks for fresh context windows; template the plan and, when it fails, fix the plan/template rather than patch the code; demoed as the git-native seeds tracker whose sd plan decomposes a spec into child issues with blocks/blockedBy edges). The whole system is deliberately lightweight — "buildable in an afternoon, no servers, use the tools you already have." For teams, consistent rituals and a shared substrate are make-or-break because the real bottleneck at scale is variance across contributors, not the model.

Concepts introduced

Agent Rituals — the fixed begin/middle/end steps every agent runs, declared in the context file so behaviour is consistent across models, harnesses, and (critically) contributors.
Context Substrate — an agent-first, structured, queryable memory layer anchored to code sections; agents prime it before work and record learnings after (demoed as mulch).

Concepts touched (existing)

Spec-Driven Development — the planning pillar corroborates and sharpens it: front-load 90% on a decomposed plan to avoid the review loop; fix the plan/template, not the broken code.
Agent Task Graph — seeds' sd plan is a second concrete instance: decompose into child seeds wired by blocks/blockedBy; plus the decompose-to-fresh-context-window rationale.
CLI Tools over MCP Servers — mulch/seeds are agent-first CLIs (ml, sd), corroborating CLI-as-agent- surface from the memory-store angle.
AI Second Brain — the structured substrate is its agent-first foil; see the tension below.
Agentic Simplicity — "buildable in an afternoon, no servers, use what you already have" is the simplicity thesis applied to this whole stack.

Held, not dropped

"Models are good enough — the model is not the bottleneck." The load-bearing framing of the whole talk. Recurs across the graph (loop-engineering, agentic-simplicity) but has no dedicated page; spin out harness-over-model-capability if a second explicit source lands on it.
Team / org-level agent consistency. The "make-or-break for teams" angle — standardising agents across dozens/hundreds of engineers. Currently a claim inside Agent Rituals; hold as a candidate concept (team-agent-consistency) if it deepens.
LLM sycophancy drives the endless review loop. "LLMs are built to please, so they'll find a problem every time you ask" — a distinct observation about why review loops never converge. Hold as sycophantic-review-loop (relates to Agent Supervision).

Key claims

Frontier models are good enough; the bottleneck is now the harness — context engineering and consistency, not model capability. observation — the talk's thesis; a framing/observation about the current state of the field, not a durable law. → held (harness-over-model).
Standardising the begin/middle/end steps every agent runs, declared in the context file, is how you make agent behaviour consistent and repeatable. principle → Agent Rituals
For teams, consistent rituals and a shared substrate across contributors are make-or-break — the binding constraint at scale is variance across people, not the model. (best practice) — context: teams of many engineers on one codebase. → Agent Rituals
A context substrate should be agent-first and anchored to code sections, primed before work and recorded to after. principle → Context Substrate
For an agent-to-agent store, structured data beats markdown (concision, low ambiguity, queryable from the start); markdown rots and invites verbose creative writing. (best practice) — context: agent-first stores only; in explicit tension with "boring markdown is beautiful." → Context Substrate, tension with AI Second Brain
Front-load ~90% of attention on a decomposed plan to avoid the never-converging review loop (LLMs are "built to please" and will always find problems). (best practice) — context: most projects; high-security/compliance work still needs a review step. → Spec-Driven Development
Decompose into atomic tasks handed to fresh context windows — five agents × 100 lines beat one agent × 500 lines. (best practice) — context: LLM coding where long single runs degrade. → Agent Task Graph
When a plan fails, fix the plan/template — not the broken code — to kill the class of problem once. (best practice) — context: templated planning with recurring failure classes. → Spec-Driven Development, Reusable Workflow Library
The whole system is lightweight — buildable in an afternoon, no servers or fancy tools. observation → Agentic Simplicity

Why this builds on the graph (and where it contradicts)

This is the second-brain / spec-driven / task-graph cluster seen from the agentic-coding practitioner angle, and it builds on it: it introduces two new named pillars (Agent Rituals, Context Substrate) and a working, CLI-backed implementation (mulch + seeds) for ideas the graph already held abstractly. It corroborates several existing stances from an independent source — CLI Tools over MCP Servers (agent-first stores are CLIs the agent drives), Agent Task Graph (sd plan's blocks/blockedBy decomposition), Spec-Driven Development (plan-first, effort front-loaded), and Agentic Simplicity ("no fancy tools, build it in an afternoon").

The high-value tension is with AI Second Brain. That page's consensus — echoed by Agentic Simplicity — is that a knowledge store is "just files and folders… boring markdown is beautiful," portable and tool-agnostic because it's plain markdown. This talk argues the opposite for its substrate: markdown "becomes extremely difficult to maintain, gets outdated, and promotes creative writing," so structured data beats markdown. The contradiction is real but reconcilable on one axis — who reads the store. Nate Herk's second brain is read by humans and agents, so portable markdown wins; Jaymin West's substrate is agent-only, machine-queried, so structured records win (he even concedes markdown "could work" as a substrate). The graph should hold both, split by reader — which is exactly why Context Substrate exists as a distinct page rather than being folded into AI Second Brain.

Illustrated walkthrough

Visual coverage of this capture is low: the largest un-illustrated stretch is ~303 s (t≈08:26→13:29, the entire Planning and Decompose/Template discussion), and a second ~240 s gap (t≈02:21→06:22) swallows the Structured Data Beats Markdown argument. Those sections are talking-head + slides; the frame sampler under-samples text-on-solid-background changes, so absence of a frame there is not absence of an on-screen slide — read those beats from the transcript, not from missing images. The demo sections (mulch, seeds) are well-covered and carry the concrete detail below.

t=00:00 — Cold open (black frame). Thesis stated in voice: "models are good enough… what matters now is the harness, the context engineering, the context substrate, and agentic rituals," and "for teams the bottleneck isn't model capability, it's consistency across contributors and their agents."
t=01:19 (f0003) — VS Code on a repo called Burrow ("OS-isolated sandbox runtime for coding agents"), CLAUDE.md open: Tech Stack (Bun + TypeScript strict + Biome + SQLite via bun:sqlite), Build/Test commands, and a Quality Gates section ("run all three before committing — warnings count as failures"). Note .mulch/ and .seeds/ already in the tree — the two tools this talk demos. He scrolls down to the agent rituals ("at the start of every session do this… while working do this… before you finish do this").
t=02:47 — (blind gap; audio only) The structured-data-over-markdown argument: LLMs are verbose and love to produce tokens; structured data reduces ambiguity and forces concision, is queryable from the start (no grepping), and avoids the "phase-six spec.md, 800 lines long" that no developer actually reads. The substrate is "intentionally not human-first, it's agent-first," and must be dynamic because LLMs out-produce humans.
t=06:22 (f0011) — GitHub jayminwest/mulch: "Growing Expertise for Coding Agents — structured expertise files that accumulate over time, live in git, work with any agent" (tags: ai-tools, ai-memory, claude-code; 248★, MIT). Framed as a reference to copy, not a product to adopt.
t=07:03 (f0021) — CLAUDE.md "## Project Expertise (Mulch)" — the ritual wired in: ml prime at session start (inject conventions/patterns/decisions/failures), ml prime --files src/foo.ts to scope-load per path; before finishing, ml record <domain> --type <convention|pattern|failure|decision|reference|guide> --description "…", with evidence auto-populated from git (--evidence-gh, --evidence-seeds, --relates-to). ml status / ml doctor / ml prune for health, integrity, and archival; atomic writes so multiple agents record concurrently ("expertise survives git worktree").
t=07:27 (f0023) — An actual ml prime query result in the terminal: structured records grouped by domain (## schemas (1 records, updated 20h ago), ## secrets, ## ship (2 records, updated 19h ago)…), each with typed ### Patterns / ### References, short IDs ([mx-b2d96c]), dense one-paragraph descriptions, file-path anchors, and staleness timestamps. This is the "structured, timestamped, per-file-anchored, agent-written" substrate made concrete — "I as a human am almost never running this command."
t=08:26 — (start of the ~303 s blind gap; audio only) Planning: ~90% of attention belongs up front; the four beats are plan → decompose → validate → repeat. LLMs are "built to please," so asking one to find problems yields endless phantom problems — the review loop you never escape; a solid decomposed plan avoids it ("a haiku-class agent could just implement it"). Decompose so fresh context windows stay at max capacity (five agents × 100 lines beat one agent × 500 lines; long single runs hit context compaction/overload). Template the planning; when a plan fails after implementation, go back and fix the plan/template — scrap the code, don't patch it — to kill that class of problem once. (Caveat he repeats: high-security/compliance work still needs a real review step.)
t=13:29 (f0031) — GitHub jayminwest/seeds: "Git-native issue tracker for AI agent workflows. Zero dependencies, JSONL storage, Bun runtime" (75★, MIT; note the commit "Remove beads… seeds is now the sole issue tracker" — a beads-like tool, git-native).
t=14:29 (f0034) — CLAUDE.md "## Issue Tracking (Seeds)" + a live sd plan show. The sd surface: sd ready (find unblocked work), sd search, sd create --title --type task --priority, sd update --status, sd close, sd dep add <id> <depends-on>, sd sync (git before push). Crucially sd plan "spawns one child seed per step and wires step.blocks into blockedBy dependencies" — the Agent Task Graph made git-native. The terminal shows a decomposed plan with numbered steps (each with a blocks: count), a risks list, and acceptance criteria — Children (8).
t=14:55 — (coverage-floor frames) "Agent rituals in action": he types only "work on this seed" into Claude Code; the agent reads the seed + related issues + the plan, runs mulch prime on the files it will touch (~133 lines of scoped context), does the work, then at session end runs the seeds close-out and records learnings into mulch — all because the rituals are declared, so "the only prompt I have to send is 'work on this seed.'"
t=16:14 (f0041) — Summary diagram: Effective agent run → three pillars (Rituals: CLAUDE.md/AGENTS.md, same steps every run; Context substrate: queryable, file-anchored, structured over markdown; Planning: 90% of your attention, front-loaded, not reviewed). "Planning, expanded": Decompose → Validate → Build, with "if it fails, return to the plan — never patch broken code." Footer: "Models are good enough" (provider-neutral, harness-agnostic, "the model is not your bottleneck") and "For teams" (consistency across contributors, shared substrate, shared rituals). (Minor mismatch to note: the spoken four-beat loop is plan/decompose/validate/repeat; the slide compresses it to decompose/validate/build.)
t≈18:00 — Close: it's not a one-shot setup — you strengthen the system over time and build trust in every agent incrementally. Challenge to the viewer: "use the tools you're already using… go implement agent rituals, figure out your context substrate (even if it's just markdown files), and really plan+decompose before you send work off — you'll see gains immediately."