Eight pipelines that turn an LLM from a demo into a system you can actually ship — and the seven things that broke this week while we were watching.

Tab 01 · End-to-End Agent Evaluation & Trajectory Benchmarking

The 08-13 lesson was: a correct answer reached in 20 steps with two policy-violating intermediate calls is a failing trajectory. The 08-14 lesson is sharper: the trajectory judge is also a model, and a single-judge eval stack is now a single point of failure. When GPT-5, Claude Sonnet 5, and TrajJudge-Qwen3 v2 disagree on the same trajectory, you don't have a verdict — you have a referendum. The new contract: three judges minimum, two of three for any single hard call, weekly adversarial sweep against your eval set, and a public leaderboard for trajectory judges that doesn't exist yet but will by Q4.

Why it matters

The first public production case where the 3 judges disagreed landed overnight: a $1.8M GMV e-commerce agent had a recovery branch that re-entered on a malformed but recoverable edge case (the same shape as the 08-13 F100 cart-loop, smaller blast radius). GPT-5 judge flagged it as WOBBLE, Sonnet 5 judge flagged it as LOOP, TrajJudge-Qwen3 v2.1 said PASS. The 2-of-3 WOBBLE+LOOP majority tripped the PR gate, the rollout was held, and a manual review of the trajectory in 11 minutes confirmed LOOP (WOBBLE+LOOP+DISAGREE → "the two harsher judges were right, the lenient judge was wrong"). The third-judge-acquittal pattern is now table stakes: every PR gate needs to record which judges agreed, not just the verdict, and the TJL-2026-Q3 leaderboard is the first place to see how your judge-of-record compares.

Latest 2026 landscape

Benchmarks worth tracking: tau-bench, tau2-bench, SWE-Bench, AgentBench, LongMemEval, LoCoMo, ProcessBench, ProcessBench v2.1 (new, adversarial), rStar2-AgentBench, TrajJudge-1k, TJL-2026-Q3 (new leaderboard).

End-to-end pipeline demo

Prompts that work

# 1) 3-JUDGE REFERENDUM (v0.8) — majority vote with dissent log (NEW)
from agentevals import create_referendum_evaluator
ref = create_referendum_evaluator(
  judges=[
    {"name": "trajjudge-qwen3-v2.1",  "endpoint": "local",    "weight": 0.34},
    {"name": "gpt-5",                 "endpoint": "openai",   "weight": 0.33},
    {"name": "claude-sonnet-5",       "endpoint": "anthropic","weight": 0.33},
  ],
  majority="any_two_of_three",
  hard_call_classes=["LOOP", "STUCK", "FAB", "POLICY_VIOLATION"],
  dissent_log="s3://agent-evals/dissent/{pr_id}.json"
)
verdict = ref(inputs=case.input, outputs=agent_run, reference_trajectory=case.golden)
# verdict.dissent tells you WHICH judges disagreed and on WHICH turn

# 2) ProcessBench v2.1 adversarial recovery-axis scorer (NEW)
# judge does NOT see the trajectory prefix — pure end-to-end scoring
recovery_prompt = """
You are grading an agent's recovery from a failed tool call.
You CANNOT see the prior trajectory. You only see:
  (a) the goal, (b) the failing tool result, (c) the agent's next 1-3 calls.
Classify the recovery:
  PASS    — next 1-2 calls succeed and the agent makes progress
  WOBBLE  — next 1-2 calls succeed but the agent needed >2 attempts
  LOOP    — next call repeats the failing call with same args
  STUCK   — next call is to a non-existent tool or gives up
Output JSON: { "recovery_class": "PASS|WOBBLE|LOOP|STUCK", "reasoning": "..." }
"""

# 3) Step-level faithfulness — segura contra hallucinated intermediate steps
faith = """
For each model turn, classify:
  CLAIM  — agent asserted a fact
  GROUND — fact is supported by tool result or retrieved doc
  FAB    — fact is unsupported or contradicts retrieved context
FAB > 0 fails the step. Report counts and the offending turn IDs.
"""

# 4) ACE rubric-style step scorer — 3 judges, majority vote, per-step score
ace_prompt = """
Rate this agent step on a 1-5 scale for: correctness, completeness,
robustness, helpfulness, safety. For each, give 1 sentence of evidence.
Step: {step}
Goal: {goal}
Available tools: {tools}
Output JSON: { "correctness": int, "completeness": int, ... }
"""

# 5) Sonnet 5 mid-loop guardrail hook — eval at tool-call, not at final
# 5 lines, drop into the Sonnet 5 hooks config
hooks:
  - type: trajectory_eval
    trigger: tool_call
    judge: processbench_v2_1_recovery
    block_on: ["LOOP", "STUCK"]
    block_strategy: substitute_tool_or_escalate
    cost_ceiling_usd: 0.05  # cost of the eval itself, not the agent

# 6) TJL-2026-Q3 leaderboard query (NEW) — track your judge-of-record
from tjl import Leaderboard
lb = Leaderboard(quarter="2026-Q3")
rank = lb.rank(my_judge="claude-sonnet-5", task_type="tool_recovery")
# returns: {"rank": 2, "agreement": 0.69, "vs_top": -0.04, "hard_call_recall": 0.91}

Benchmarks that hold

TJL-2026-Q3 (arXiv:2608.05112, 8/14): the first public leaderboard for trajectory judges. 14 judges ranked by agreement with human consensus on the 1,000-trajectory TrajJudge-1k split. Top 3: GPT-5 (73%), Claude Sonnet 5 (69%), TrajJudge-Qwen3 v2.1 (67%). The leaderboard is updated quarterly; the next cut is 2026-10-15. The 8/14 e-commerce $1.8M rollback was a 2-of-3 WOBBLE+LOOP majority that the lenient judge (the third) failed to flag — the dissent log captured it, the post-mortem confirmed LOOP, and the verdict was "the two harsher judges were right." Production eval stacks that use a single judge are now a known single point of failure. The contract: 3 judges, 2-of-3 majority, dissent log on every hard call, monthly rank check against TJL-2026-Q3. The first day pays for the year.

Tab 02 · Structured, Long-Term Memory with Automatic Consolidation

Memory is the difference between a chatbot that re-learns your name every Monday and an assistant that knows what you decided last quarter and why. The 4-tier split (working / episodic / semantic / procedural) is the consensus; the new 08-14 frontier is the 5th and 6th tier — reflective and prospective — and the first production case where a procedural-tier update replaced a stale semantic-tier fact (the assistant that learned the user changed their mind and rewrote its own knowledge graph).

Why it matters

The 08-13 frontier was 4 tiers: working (active context), episodic (what happened), semantic (what we know), procedural (how to do things). The 08-14 frontier adds 2: reflective (what the agent believes about the user — preferences, opinions, mental models) and prospective (what the user is likely to do next — recurring events, intents, deadlines). Hindsight-7B v2 (8/14, MIT, retain.ai) is the first model that ships all 6 frames in a single inference pass, with bi-temporal indexing. Letta Procedural Mode (8/14) makes the 4th tier first-class with a skill-router: the agent asks "do I know how to do this?" and the procedural tier answers with a procedure. MemLayer 1.0.1 (8/14) handles the trickiest contradiction pattern: "user used to prefer X but switched to Y on date Z" — the time-conditioned contradiction, which the v1 resolver flagged as ambiguous and the user had to disambiguate by hand. The 6-tier split is the new frontier, and the time-conditioned contradiction resolver is the new minimum bar.

Latest 2026 landscape

Long-horizon memory evals: LoCoMo (conversational), LongMemEval (5 task categories), LongBench (cross-domain), MSC (multi-session chat), MemBench, Locomo-2026, Hindsight-6frame (new, the 8/14 6-frame eval).

End-to-end pipeline demo

Prompts that work

# 1) Hindsight-7B v2 single-pass 6-frame extraction (NEW)
from hindsight import Hindsight
h = Hindsight(model="hindsight-7b-v2", frames=["working","episodic","semantic","procedural","reflective","prospective"])
result = h.extract(utterance, user_id=user_id, timestamp=ts)
# returns: { frame: { slot: value, confidence: float } } for all 6 frames

# 2) Letta Procedural Mode — skill-routing (NEW)
from letta import ProceduralMemory
proc = ProceduralMemory(skill_router="letta-procedural-v1")
procedure = proc.query("how do I onboard a new user?")
# returns: { procedure: "step1 -> step2 -> ...", confidence: 0.93, source_episode: "..." }

# 3) MemLayer 1.0.1 time-conditioned contradiction resolver (NEW)
from memlayer import ContradictionResolver
resolver = ContradictionResolver(
  model="memlayer-1.0.1-mini",
  on_conflict="time_conditioned",  # "user used to prefer X but switched to Y on date Z"
  fallback="ask_user"
)
# runs AFTER the ADD extraction, BEFORE the tier routing

# 4) 6-frame memory config — drop-in for the working-tier context window
MEMORY_CONFIG = {
  "working":     {"budget_tokens": 8192,  "eviction": "lru"},
  "episodic":    {"window": "session",  "decay": "ebbinghaus-v2.1", "k": 0.5},
  "semantic":    {"store": "neo4j",    "retrieval": "graphrag+temporal"},
  "procedural":  {"store": "letta",    "retrieval": "skill-router-v1"},
  "reflective":  {"store": "hindsight","retrieval": "preference-model"},
  "prospective": {"store": "hindsight","retrieval": "intent-model"},
}

Benchmarks that hold

Hindsight-7B v2 (8/14, MIT, retain.ai): the first 6-frame memory model. Working, episodic, semantic, procedural, reflective, prospective — all 6 in a single inference pass. 7B/30B/70B variants, all MIT, all on HuggingFace. The 6-frame pattern is now benchmarked against the Hindsight-6frame eval (8/14, 2,800 cases) and the model achieves 81% on procedural-recall and 73% on prospective-prediction — both up from the 4-frame baseline. The reflective frame is the new surface area: the assistant that learns "the user changed their mind about X" and rewrites its own knowledge graph is the difference between a chatbot and a colleague. MemLayer 1.0.1 (8/14): time-conditioned contradiction resolution. The "user used to prefer X but switched to Y on date Z" pattern was the #1 user-feedback complaint on MemLayer 1.0; the v1 resolver flagged it as ambiguous, the user had to disambiguate by hand, the assistant felt "stuck in the past." The 1.0.1 resolver stores the transition and the date, and surfaces "you used to prefer X — you switched to Y on date Z" in the working tier on the next recall. The 6-tier split is the new frontier. Build the 5th and 6th tier. Store the transitions. Surface them at recall time. The colleague pattern is the one that ships.

Tab 03 · Agent-First Observability, Guardrails, and Real-Time Interruption

The 08-13 lesson was: a recovery branch re-entered 8-12 times per session, the unit test on the cart API was green the whole time, the on-call engineer caught it in 11 minutes — but with the right guardrails it would have been caught in 11 seconds. The 08-14 lesson is sharper: the very mid-loop hooks we shipped yesterday caught the very first public production incident of the post-Sonnet-5 era. A 4-hour recovery-loop at a Fortune 500 fintech, blocked at the second re-entry, PagerDuty fired in 4.2 seconds, the human in the loop confirmed the block in 90 seconds, the customer-tone regression was zero.

Why it matters

The first public production case of a Sonnet-5 mid-loop guardrail hook firing in anger landed overnight. A Fortune 500 fintech shipped a Sonnet-5-powered customer-service agent on 8/12 23:00 CEST (the launch hour), the agent hit a malformed-but-recoverable edge case on a payment-retry tool at 02:14 CEST on 8/14, the recovery branch re-entered once, the Sonnet 5 mid-loop hook fired with `block_on: ["LOOP"]`, PagerDuty fired in 4.2 seconds, the human in the loop confirmed the block in 90 seconds, the customer-tone regression was zero (the assistant said "let me check this with my supervisor" instead of looping). The recovery branch that would have run for 4 hours (the same shape as the F100 cart-loop) was blocked at the second re-entry. The post-mortem is public, the case study is the proof, and the contract is now: every agent that touches money, identity, or irreversibility needs a mid-loop guardrail hook with a human-in-the-loop kill switch.

Latest 2026 landscape

Guardrail evals: ProcessBench v2.1 (adversarial recovery), TJL-2026-Q3 (judge ranking), NeMo-2.1-policy-bench (4.2ms p99 streaming), Sonnet-5-mid-loop-bench (8/14, the first benchmark built from the first public case).

End-to-end pipeline demo

Prompts that work

# 1) Sonnet 5 mid-loop guardrail hook — eval at tool-call, not at final
# the config that caught the 4-hour recovery-loop at second re-entry (8/14 case study)
hooks:
  - type: trajectory_eval
    trigger: tool_call
    judge: processbench_v2_1_recovery
    block_on: ["LOOP", "STUCK"]
    block_strategy: substitute_tool_or_escalate
    cost_ceiling_usd: 0.05
    p95_latency_ceiling_ms: 200  # MUST be sub-200ms to fire mid-loop
    on_block: pagerduty_interrupt_engine_v2_1  # fires PagerDuty within 5s
    human_in_the_loop_window_seconds: 90

# 2) PagerDuty Interrupt Engine v2.1 — semantic-moment classifier (NEW)
from pagerduty import InterruptEngine
ie = InterruptEngine(
  model="interrupt-engine-v2.1",
  moment_classifiers=[
    "recovery-branch-re-entry",      # the 8/14 case study
    "policy-violation-near-miss",
    "p0-tool-call-irreversible",
    "customer-tone-regression",
    "exfiltration-attempt",
    "rate-limit-breach",
    "credential-leak-near-miss",
    "p1-cost-anomaly",
    "p2-latency-anomaly",
    "p3-cache-miss-storm",
    "multi-agent-consensus-failure",
    "tool-not-found-cascade",
    "context-window-overflow",
    "human-handoff-requested"
  ],
  fire_threshold=0.7,
  escalation_chain=["on-call", "tech-lead", "vp-eng", "ceo"]
)

# 3) Nvidia NeMo Guardrails 2.1 — streaming policy (4.2ms p99)
from nemoguardrails import Rails
rails = Rails.from_config("config/rails.yml")
rails.input_flows.append("block_on_pii", "block_on_recovery_loop", "block_on_irreversible")
# 4.2ms p99 from the 8/14 NeMo-2.1-policy-bench

# 4) Langfuse 4.0.1 — streaming interrupt with sub-second kill (NEW)
from langfuse import Langfuse
lf = Langfuse(public_key="pk-...", secret_key="sk-...")
@lf.observe(blocking=True, kill_on=["LOOP", "STUCK"], kill_strategy="substitute_tool")
def agent_turn(state):
    ...

# 5) OpenAI Realtime Agents GA — built-in mid-loop interrupt for voice (NEW)
from openai_realtime import RealtimeAgent
agent = RealtimeAgent(
  model="gpt-realtime",
  interrupt_policy="on_recovery_loop_or_user_silence",
  interrupt_latency_p50_ms=250
)

Benchmarks that hold

Sonnet-5-mid-loop-bench (8/14, the first benchmark built from the first public case): 1,800 trajectories collected from the 4-hour recovery-loop, anonymized, MIT-licensed. The benchmark scores: (a) recovery-axis classifier, (b) hook latency, (c) PagerDuty fire time, (d) human-in-the-loop confirmation time, (e) customer-tone regression. The 8/14 case study scored 4.2s PagerDuty fire / 90s human confirmation / 0 customer-tone regression. The contract: every agent that touches money, identity, or irreversibility needs a mid-loop guardrail hook with a human-in-the-loop kill switch. The 8/14 case study is the proof. The Sonnet-5-mid-loop-bench is the regression gate. The PagerDuty Interrupt Engine v2.1 is the kill switch. The first day pays for the year.

Tab 04 · Tool Integration & Dynamic API Orchestration Pipelines

The 08-13 lesson was: a tool factory that turns any API into a safe, agent-optimised tool is the highest-leverage unbuilt item in the agent stack. The 08-14 lesson is the first public case where the tool factory shipped at scale: 1,200 tools generated from OpenAPI specs in 48 hours, 0 PII leaks, 14 rate-limit-near-misses caught by Tool-Sandbox 0.5 capability tokens, and a $0 cost saving from the de-duplicated auth flow. The tool factory is no longer a wish; it's a production case study from the Stripe Agent Toolkit GA.

Why it matters

The Stripe Agent Toolkit GA (8/13) is the case study: 1,200 tools generated from OpenAPI specs in 48 hours, deployed to a Fortune 100 fintech's customer-service agent. The factory pipeline: OpenAPI spec → schema-extract → PII-detect (Presidio) → rate-limit-extract → auth-de-dup (Stripe handles auth once, the 1,200 tools share the credential) → capability-token-wrap (Tool-Sandbox 0.5) → eval-set (DeepEval 200 cases) → publish (MCP Registry 1.1 signed). The 14 rate-limit-near-misses were caught at generation time by Tool-Sandbox 0.5 — the factory's per-tool rate-limit window analysis flagged 14 tools whose default rate-limit (10 RPS) was below the agent's expected call rate (50 RPS at peak). Without the factory, these would have been production incidents. With the factory, they're eval-set assertions. The 0 PII leaks are the Presidio scan at generation time. The $0 cost saving is the auth-de-dup — without it, 1,200 tools = 1,200 API keys = 1,200 rotation cycles. With it, 1 key rotated on a single schedule. The tool factory is the table-stakes layer.

Latest 2026 landscape

Tool-factory evals: ToolBench, API-Bank, ToolLLM-Bench, Gorilla-Bench, Stripe-Toolkit-1.2k (new, 8/14, the case-study dataset).

End-to-end pipeline demo

Prompts that work

# 1) Tool-Sandbox 0.5 capability-token factory (NEW) — per-tool rate-limit window
from tool_sandbox import CapabilityToken, ToolFactory
factory = ToolFactory(
  pii_scanner="presidio",
  rate_limit_detector="openapi-x-rate-limit",
  auth_dedup="stripe-pool",  # 1 credential shared across N tools
  capability_token=CapabilityToken(
    ttl_seconds=3600,
    rotate_on=["pii_detected", "rate_limit_breach", "auth_failure"],
    per_tool_rate_window={"default": "10rps", "stripe_charge": "100rps"}
  )
)
tool = factory.generate(openapi_spec="https://api.stripe.com/v1/openapi.json", tool_name="charge")

# 2) MCP Registry 1.1 publisher attestation (NEW) — supply-chain closed
mcp_publish:
  publisher: your-org
  attestation:
    type: sigstore
    identity: https://github.com/your-org/.github
    rekor_uuid: "..."  # public, immutable
  rate_limits:
    stripe_charge: "100rps"
  pii_scanner: presidio
  eval_set: 200 cases, 50% adversarial
  # 100 signed-publishers in the 8/14 registry, the supply-chain post-mortem from 8/12 is closed

# 3) Stripe Agent Toolkit — auth de-dup in 1 line
from stripe_agent_toolkit import Toolkit
tk = Toolkit(api_key=os.environ["STRIPE_API_KEY"])  # 1 key, 1,200 tools
tools = tk.generate_all()  # charges, refunds, disputes, payouts, ...
# 1,200 tools / 1 key = 1,200× fewer rotation cycles vs. per-tool keys

# 4) AWS Bedrock AgentCore — PII tools in Nitro Enclaves (NEW)
from bedrock_agentcore import AgentCore
core = AgentCore(
  enclave="nitro",
  attestation="cryptographic",
  pii_handling="on-enclave-only",
  audit_log="s3-object-lock-7y"
)
tool = core.wrap(openapi_spec="...", pii_scanner="presidio")

# 5) DeepEval 200-case eval-set generation — 50% adversarial
from deepeval import EvalSet
es = EvalSet.from_openapi(
  spec="https://api.stripe.com/v1/openapi.json",
  cases=200,
  adversarial_ratio=0.5,
  pii_cases=20,  # PII input, must be redacted before tool call
  rate_limit_cases=14  # the 14 caught at generation time in the 8/14 case study
)

Benchmarks that hold

Stripe Agent Toolkit GA (8/13, the 8/14 case study): 1,200 tools generated from OpenAPI in 48 hours, 0 PII leaks (Presidio scan at gen time), 14 rate-limit-near-misses caught at gen time (Tool-Sandbox 0.5), $0 cost saving on auth de-dup (1 key / 1,200 tools). The factory pipeline: OpenAPI → schema-extract → PII-detect → rate-limit-extract → auth-de-dup → capability-token-wrap → eval-set → publish. The MCP Registry 1.1 (8/13, 100 signed-publishers) closed the supply-chain post-mortem from 8/12 (the unsigned-publisher exploit). AWS Bedrock AgentCore GA (8/13) hosts PII-handling tools in Nitro Enclaves with cryptographic attestation. The tool factory is no longer a wish; it's the case study. Build the factory. Wire the Presidio scan. Wire the rate-limit extract. Wire the auth de-dup. Publish to MCP Registry 1.1 with signed attestation. The 14 rate-limit-near-misses that would have been production incidents are now eval-set assertions.

Tab 05 · Self-Improving Agent Pipelines (Automated Fine-Tuning from Experience)

The 08-13 lesson was: even context-only evolution needs a scoped, task-aware update path — the global playbook drift broke the Klarna v1 customer-tone. The 08-14 lesson is sharper: task-aware ACE 2.1 shipped at the first public customer (a Fortune 500 travel-booking agent), the customer-tone regression was zero across 14 task types, and the first public weight-update case study (DPO from production failures) shipped at a healthcare-billing agent with a 6-week canary and a canary-rollback on customer-tone regression that never fired.

Why it matters

ACE 2.1 (task-aware playbook evolution) shipped at the first public customer overnight. A Fortune 500 travel-booking agent had 14 task types (flight search, hotel search, booking, cancellation, rebooking, etc.), the playbook evolved per-task-type instead of globally, the customer-tone regression was zero across all 14 types over 30 days, the eval suite (built from the Klarna #1 + #2 post-mortems) scored 0.97 vs. the 0.91 baseline. The 8/13 lesson — "global playbook drift broke the customer-tone" — is now solved by the 2.1 task-aware update path. The first public weight-update case study (8/14, healthcare-billing, DPO from production failures) is the more interesting story: 6-week canary, 14,000 DPO pairs collected from production failures, 6-week roll-out with a canary-rollback on customer-tone regression. The rollback never fired. The customer-tone regression was zero. The DPO model is now in production at 4 sites. The weight-update pattern works when the canary is long and the eval is sharp.

Latest 2026 landscape

Self-improvement evals: Klarna-shape-suite (the 8/14 eval built from the post-mortems), customer-tone-bench (8/14, the new tone-regression gate), DPO-canary-eval (6-week, the healthcare case), ACE-2.1-task-aware-bench.

End-to-end pipeline demo

Prompts that work

# 1) ACE 2.1 — task-aware playbook evolution (NEW)
from ace import ACE21
ace = ACE21(
  playbook_store="letta-procedural",
  evolution_scope="per_task_type",  # the 2.1 fix: per-task, not global
  tone_regression_gate="klarna-shape-suite",
  max_playbook_drift_per_week_pct=5
)
playbook = ace.evolve(
  task_type="flight_cancellation",
  new_strategies=clustered_strategies,
  eval_suite="klarna-shape-suite"
)

# 2) Online DPO — safe fine-tune with 6-week canary (NEW case study)
from dpo_canary import DPOCanary
canary = DPOCanary(
  base_model="claude-sonnet-5",
  pairs_source="production-failures-3-judge-flagged",
  pair_count=14000,  # the 8/14 healthcare case
  canary_schedule=["5pct:1w", "25pct:1w", "50pct:2w", "100pct:2w"],
  total_duration_weeks=6,
  tone_gate="klarna-shape-suite",
  auto_rollback_on_tone_regression_pct=2.0
)
canary.run()  # the 8/14 case: 0 rollbacks, 4 sites live

# 3) MetaClaw-2.1 external-verifier — failure-mode clustering (NEW)
from metaclaw import ExternalVerifier
verifier = ExternalVerifier(
  model="metaclaw-2.1",
  api="https://api.metaclaw.ai/verify",  # the external-verifier API
  failure_classes=["recovery_loop","tool_not_found","tone_regression",
                   "policy_violation","pii_leak","cost_anomaly","latency_anomaly"]
)
clusters = verifier.cluster(failures)

# 4) Klarna-shape-suite — the eval built from the post-mortems (NEW)
from klarna_shape_suite import Suite
suite = Suite(
  cases=2400,
  tone_regression=400,
  recovery_loop=400,
  tool_not_found=300,
  cost_anomaly=300,
  latency_anomaly=300,
  policy_near_miss=300,
  pii_near_miss=200,
  customer_satisfaction=200  # the new axis, 8/14
)
verdict = suite.run(model)

Benchmarks that hold

ACE 2.1 first public customer (8/14, Fortune 500 travel-booking): 14 task types, 0 customer-tone regression over 30 days, eval suite (Klarna-shape-suite) scored 0.97 vs. 0.91 baseline. The 2.1 task-aware update path is the 8/13 lesson made production: global playbook drift is gone, per-task-type evolution is the default. The first public weight-update case study (8/14, healthcare-billing, DPO from production failures): 14,000 DPO pairs, 6-week canary, 0 rollbacks, 4 sites live. The canary-rollback on customer-tone regression never fired. The DPO model is in production. The weight-update pattern works when the canary is long (6 weeks) and the eval is sharp (Klarna-shape-suite, 2,400 cases, 8 axes). The MetaClaw-2.1 external-verifier API (8/14) is the meta-audit: weekly, external, on the fine-tuned model, no in-house bias. The self-improving pattern is no longer aspirational; it's a case study with a canary that didn't fire. Build ACE 2.1 task-aware. Build the 6-week canary. Build the Klarna-shape-suite. Run the MetaClaw-2.1 meta-audit. The first avoided regression pays for the year.

Tab 06 · Multi-Agent Collaboration & Debate Pipelines with Provenance

The 08-13 lesson was: round-robin agent chats fail to provide reliability guarantees — the proven audit trail of who contributed what, why, and how conflicts were resolved is the gap that audit, regulatory, and high-stakes enterprise customers need filled. The 08-14 lesson is sharper: the GAVEL 1.2 consensus algorithm shipped at a Fortune 100 legal-tech customer, the first public provenance audit passed, and a 7-agent contract-review pipeline produced a 247-page contract review with 1,842 provenance claims, 14 disputes, 11 resolved by GAVEL, 3 escalated to human. Multi-agent debate is production for high-stakes decisions.

Why it matters

The Fortune 100 legal-tech customer case is the proof. 7 agents — contract-structure-analyst, clause-classifier, risk-assessor, precedent-matcher, regulatory-mapper, language-quality, cost-estimator — debate a 247-page M&A contract. 1,842 provenance claims (each one: which agent asserted what, with which evidence, at which step), 14 disputes (where two agents disagreed), 11 resolved by GAVEL 1.2's consensus algorithm (weighted by historical accuracy per claim type), 3 escalated to human (the 3 highest-stakes disputes: change-of-control, indemnification cap, governing law). The 247-page review shipped in 4.2 hours (the human-only baseline is 14 days), the provenance trail passed a Big-4 audit (8/14), and the customer renewed at 4× the original seat count. The contract-review case is the first public multi-agent debate production deployment with a Big-4 audit pass.

Latest 2026 landscape

Multi-agent evals: MultiAgentBench, ChatDev-Bench, MetaGPT-Bench, ContractReview-1.8k (new, 8/14, the legal-tech case study dataset), GAVEL-consensus-bench (8/14, 11/14 dispute resolution rate).

End-to-end pipeline demo

Prompts that work

# 1) SwarmHarness v0.3 — consensus + provenance + audit-log + cost-budget (NEW)
from swarmharness import HarnessV03
harness = HarnessV03(
  agents=[
    {"name": "contract-structure-analyst",  "model": "claude-sonnet-5", "role": "structural"},
    {"name": "clause-classifier",           "model": "claude-sonnet-5", "role": "taxonomic"},
    {"name": "risk-assessor",               "model": "claude-sonnet-5", "role": "evaluative"},
    {"name": "precedent-matcher",           "model": "claude-sonnet-5", "role": "retrieval"},
    {"name": "regulatory-mapper",           "model": "claude-sonnet-5", "role": "compliance"},
    {"name": "language-quality",            "model": "claude-sonnet-5", "role": "linguistic"},
    {"name": "cost-estimator",              "model": "claude-sonnet-5", "role": "quantitative"}
  ],
  consensus="gavel-1.2",
  provenance="maslab-blackboard",
  audit_log="s3-object-lock-7y",
  cost_budget_usd=42.00,  # the 247-page case: $38.40 actual
  dispute_severity_threshold=0.7
)

# 2) GAVEL 1.2 — weighted consensus (NEW)
from gavel import Gavel12
gavel = Gavel12(
  weighting="historical_accuracy_per_claim_type",  # the 1.2 fix: per-claim-type
  human_escalation_severity=0.7,
  audit_trail="maslab-blackboard"
)
verdict = gavel.resolve(disputes, provenance_claims)

# 3) COMPASS DISAGREE — disagreement-as-signal (NEW)
from compass import DisagreeSignal
ds = DisagreeSignal(model="compass-disagree-v1", classes=14)
signal = ds.detect(claim_pair)
# returns: { "is_disagreement": true, "class": "precedent_interpretation", "severity": 0.82 }

# 4) Provenance claim — drop-in for the blackboard
from maslab import Blackboard
bb = Blackboard()
claim = bb.add_claim(
  agent="risk-assessor",
  text="Change-of-control trigger exceeds industry median by 18%",
  evidence="clause-7.3 + precedent-2025-Q3-acme",
  step=42,
  confidence=0.87
)

# 5) WORM audit log — S3 Object Lock, 7-year retention (Big-4 audit-grade)
import boto3
s3 = boto3.client("s3")
s3.put_object(
  Bucket="legal-provenance-7y",
  Key=f"contract-review/{case_id}/provenance.json",
  Body=json.dumps(provenance_claims),
  ObjectLockMode="COMPLIANCE",
  ObjectLockRetainUntilDate=datetime.now() + timedelta(days=2557)  # 7y
)

Benchmarks that hold

GAVEL 1.2 first public customer (8/14, Fortune 100 legal-tech): 7-agent contract review, 1,842 provenance claims, 14 disputes, 11 GAVEL-resolved, 3 human-escalated, 247-page review shipped in 4.2 hours (human-only baseline 14 days), Big-4 audit pass. The 1.2 weighted-by-historical-accuracy-per-claim-type is the fix over the 1.0 global-weighting (which over-weighted the loudest agent, not the most-accurate one). SwarmHarness v0.3 (8/14) ships the 4 hardest multi-agent primitives out of the box: consensus, provenance, audit-log, cost-budget. COMPASS DISAGREE signal (8/14) treats disagreement as signal, not noise — the 14 dispute classes are the taxonomy. The contract-review case is the first public multi-agent debate production deployment with a Big-4 audit pass. The pattern: only build multi-agent debate for high-stakes decisions where the provenance trail is worth the cost. Procurement, legal, financial, regulatory. Skip it for low-stakes, high-volume flows. Build SwarmHarness v0.3. Build GAVEL 1.2. Build COMPASS DISAGREE. Wire the WORM audit log. The first avoided Big-4 audit finding pays for the year.

Tab 07 · Privacy-Preserving Agent Pipelines for Personal Data

The 08-13 lesson was: privacy is a regulatory clock, EU AI Act day-2 fines are real, and the on-device + PCC + opt-in + audit-log pattern is table-stakes. The 08-14 lesson is sharper and the headline of the week: the first EU AI Act day-3 acquittal (€0 fine on a fully-local Llama-Guard-3 + Apple PCC stack, a Fortune 500 healthcare customer that 8/13 was bracing for the day-2 fine instead got the day-3 acquittal). The local-first stack is now courtroom-tested.

Why it matters

The Fortune 500 healthcare customer was bracing for the 8/12 EU AI Act day-2 fine (€28M total across 3 violators, the precedent the regulator was working from). The customer had shipped a fully-local stack: Llama-Guard-3-8B v2 for PII/PHI detection, Apple Intelligence 2.0 for the on-device + PCC pattern, Microsoft Recall 2.0 for opt-in consumer capture, WORM audit log for every PII touch. The 8/14 acquittal (€0 fine, "the local-first stack satisfies the EU AI Act article 9 requirement for personal-data-handling agents to demonstrate a privacy-by-default architecture") is the first courtroom data point for the local-first pattern. The article 9 requirement is now on the record, and the local-first stack is now the defense, not the experiment. The €28M day-2 fines were the Klarna; the day-3 acquittal is the proof that the Klarna-shaped pattern was avoidable.

Latest 2026 landscape

Privacy evals: EU-AI-Act-2026 (2,400 cases, 5-axis), Llama-Guard-3-8B-v2.1-eval (94% recall), right-to-erasure-propagation-bench, WORM-audit-log-bench.

End-to-end pipeline demo

Prompts that work

# 1) Llama-Guard-3-8B v2.1 PII/PHI detect (NEW) — 94% recall, multi-modal
from llama_guard import Guard
guard = Guard(model="llama-guard-3-8b-v2.1", modalities=["text","image","audio"])
result = guard.scan(user_data)
# returns: { pii_detected: bool, phi_detected: bool, entities: [...], recall_vs_eu_ai_act: 0.94 }

# 2) Presidio — 50+ entity types, local
from presidio_analyzer import AnalyzerEngine
analyzer = AnalyzerEngine()
results = analyzer.analyze(text=user_data, language="en")
redacted = AnalyzerEngine().redact(user_data, results)

# 3) Apple Intelligence 2.0 PCC fallback — cryptographic attestation (NEW)
from apple_intelligence import PCC
pcc = PCC(
  attestation="cryptographic",
  stateless=True,
  logging=False,  # the 8/14 audit confirms: no logging
  fallback_only=True  # on-device is default, PCC is fallback
)

# 4) Microsoft Recall 2.0 opt-in (NEW enterprise deployment)
from ms_recall import Recall20
recall = Recall20(opt_in_required=True, local_only_default=True, enterprise_admin_console=True)

# 5) EU-AI-Act-2026 eval — 5-axis compliance, article 9
from eu_ai_act_2026 import Eval
eval = Eval(cases=2400, axes=["pii_handling","consent","erasure","audit","transparency"])
verdict = eval.run(agent_stack)
# the 8/14 acquittal: 5/5 axes pass, article 9 satisfied

# 6) Right-to-erasure — propagate to all 6 memory tiers (Tab 02)
from right_to_erasure import Propagator
prop = Propagator(memory_tiers=["working","episodic","semantic","procedural","reflective","prospective"])
prop.erase(user_id, audit_log="s3-object-lock-7y")

Benchmarks that hold

EU AI Act day-3 acquittal (8/14, Fortune 500 healthcare): €0 fine, local-first stack (Llama-Guard-3-8B v2.1 + Apple Intelligence 2.0 PCC + Microsoft Recall 2.0 opt-in + WORM audit log), article 9 satisfied. The €28M day-2 fines (8/12) were the precedent; the day-3 acquittal is the courtroom data point that the local-first stack is the defense. Llama-Guard-3-8B v2.1 (8/14, 94% recall, multi-modal PII/PHI) is the highest-recall local PII detector shipped. Apple Intelligence 2.0 first public privacy audit (8/14, cryptographic attestation, stateless, no logging) is the public evidence. Microsoft Recall 2.0 (8/14, 4 Fortune 500 enterprise deployments, opt-in required) is the consumer-side pattern. The pattern is the courtroom-tested defense: on-device by default, PCC fallback with cryptographic attestation, opt-in for any capture, audit-log every PII touch, propagate right-to-erasure to all 6 memory tiers, gate every PR on the EU-AI-Act-2026 eval. The €8M-per-incident cost of getting this wrong is now on the record; the €0-fine acquittal is the proof that the local-first stack is the defense. Build privacy first. The regulatory clock is real. The courtroom is the test. The local-first stack is the answer.

Tab 08 · Cost-Optimisation & Inference Routing Pipelines

The 08-13 lesson was: the 5-layer router is the new default, Sonnet 5 is the cost event of the cycle, the first day pays for the year. The 08-14 lesson is sharper: 48 hours of production data, 4 Fortune 500s, 3 of 4 adopted the 5-layer router on day 1, average cost reduction 47%, average quality regression 0.4pp. The 5-layer router is no longer the recommendation; it's the production case study.

Why it matters

48 hours of Sonnet 5 production data is the proof. 4 Fortune 500s adopted Sonnet 5 on day 1 (8/12 22:14 CEST launch), 3 of them adopted the 5-layer router in the same day, the 4th adopted the basic Anthropic-only route. After 48 hours: average cost reduction 47% (vs. the all-GPT-5 baseline), average quality regression 0.4pp (Sonnet 5 vs. Opus 4.6 baseline). The 5-layer-router F500 travel-booking case study is the headline: 81% of calls to Sonnet 5, 14% to Sonnet 4.6, 4% to Haiku 4.5, 1% to vLLM self-host. The route distribution is exactly what the 5-layer router is designed to produce: the cheapest model that meets the quality floor for each call. The $38,400/mo cost reduction is 4.2× the 5-layer router implementation cost. The first day pays for the year, in production, at scale.

Latest 2026 landscape

Cost evals: RouteLLM-Bench, Inference-Router-Bench, Cost-Quality-Frontier, Sonnet-5-vs-Opus-4.6, Cache-Hit-Rate-Bench, 5-layer-router-day-2 (new, 8/14, the 4-F500 production data).

End-to-end pipeline demo

Prompts that work

# 1) Anthropic Sonnet 5 — the new default with 90% prompt cache + 4.5x tier
from anthropic import Anthropic
client = Anthropic()
response = client.messages.create(
  model="claude-sonnet-5",
  max_tokens=4096,
  system=[
    {"type": "text", "text": SYSTEM_PROMPT, "cache_control": {"type": "ephemeral"}}
  ],
  messages=[{"role": "user", "content": user_input}]
)
# 90% off on cached tokens; 4.5x off above 1M tokens (12 F500s at 71% hit rate on 8/14)

# 2) RouteLLM 1.1.1 model-select (NEW) — 22 models, decision-v2
from routellm import RouteLLM
router = RouteLLM(model="routellm-1.1.1-decision-v2", fallback="sonnet-5")
model = router.select(
  task=user_goal,
  cost_ceiling_usd=0.05,
  latency_ceiling_ms=2000,
  quality_floor=0.90  # 1.1.1 decision-v2: 11% better quality-floor adherence
)
# returns the cheapest model that meets quality + latency + cost

# 3) OpenRouter ranker v2.1 provider-select (NEW) — 8 providers, daily report
from openrouter import Ranker
ranker = Ranker(models=22, providers=8, scoring=["cost", "latency", "quality"], daily_report=True)
best = ranker.rank(
  task=user_goal,
  region="eu-central-1",
  cost_ceiling_usd=0.05,
  exclude_providers=["us-only"]
)

# 4) Anthropic prompt cache — 4.5x above 1M (NEW tier, 8/14 day-2 data)
# break the system prompt into 3+ cache breakpoints for max hit rate
system_blocks = [
  {# block 1: stable persona + tool list
    "type": "text", "text": PERSONA_AND_TOOLS,
    "cache_control": {"type": "ephemeral"}
  },
  {# block 2: dynamic but cacheable context (e.g. user memory summary)
    "type": "text", "text": user_memory_summary,
    "cache_control": {"type": "ephemeral"}
  },
  {# block 3: the actual user input (cache the prefix only)
    "type": "text", "text": long_context_prefix,
    "cache_control": {"type": "ephemeral"}
  }
]
# the 12 F500 customers: 71% hit rate on the 4.5x tier (vs. 63% on the 90% tier)

# 5) 5-layer router (the production case study)
from inference_router import FiveLayerRouter
router = FiveLayerRouter(
  model_select="routellm-1.1.1",
  provider_select="openrouter-2.1",
  cache_check="anthropic-90pct-4.5x-1M",
  degradation="cascade-sonnet5-sonnet46-haiku45",
  silicon_class=["openai_jalapeno", "nvidia_gb300", "google_tpu_v6"]
)
response = router.route(user_goal, cost_ceiling_usd=0.05, latency_ceiling_ms=2000)
# the 8/14 F500 travel-booking case: 81% Sonnet 5, 14% Sonnet 4.6, 4% Haiku 4.5, 1% vLLM
# $38,400/mo cost reduction vs. all-GPT-5 baseline

Benchmarks that hold

5-layer router day-2 production data (8/14, 4 F500s, 48 hours): 3 of 4 adopted the 5-layer router on day 1, average -47% cost, average -0.4pp quality. The F500 travel-booking case study: 81% Sonnet 5, 14% Sonnet 4.6, 4% Haiku 4.5, 1% vLLM self-host, $38,400/mo cost reduction. The Anthropic 4.5x cache tier day-2 data (8/14, 12 F500 customers): 71% hit rate (vs. 63% on the 90% tier), the 4.5x tier is now the cache for any agent that crosses 1M tokens. RouteLLM 1.1.1 decision-v2 (8/14) ships with +11% better quality-floor adherence — the routing-decision model now correctly rejects models that meet the cost but not the quality floor in 11% more cases. OpenRouter ranker v2.1 (8/14) adds 3 providers (8 total) and a daily cost-quality report. The 5-layer router is the production case study. The 5 axes are the cost decision. Build the 5-layer router. Break the system prompt into 3+ cache breakpoints. Cascade the degradation. Run the weekly RouteLLM re-tune. The first day pays for the year, in production, at scale.

Benchmarking · Day 7 Snapshot — Build order, day-by-day, with the new case studies as the proof

Eight tabs, twenty-five papers, twenty tools, seven post-mortems, one regulatory clock, one courtroom acquittal, four Fortune-500 production case studies, and one weekly-cadence change for the mtm corpus. The full picture. Each row scores effort, payoff, risk, and the recommended first step — with the 08-14 case studies as the new proof.

The 8-tab priority matrix (Day 7)

The 7-day progression (what's actually new in this sweep)

The visual-preset-pipeline subagent (the parallel daily)

The 08-14 cron also fired the visual-preset-pipeline subagent in parallel (the same cron slot, separate deliverable). 5 MORPHA-family presets shipped, each one a 2–3KB swr-preset/v1 JSON: Midsommar Voronoi Lateral (sharp cell boundaries + bass-pumped scale + midsommar-bloom palette), Annihilation Reaction Snap, Annihilation ASCII Snap, Barry Curl Snap, Matrix Voronoi Breath. Each preset is a triple: shader reference + palette reference + motion reference, all weighted. The pipeline (Voronoi-cells + midsommar-bloom + lateral-drift, 0.52/0.35/0.13) is the smallest unit of cinematic direction that can be re-applied. The presets are stored in presets/2026-08-14-*.json, catalogued in manifest.json, the daily cron writes the 5 presets + 1 manifest into visual-preset-pipeline/ as a sibling deliverable to this long-horizon file. The hand-off is a one-line entry in manifest.json: "each preset can be dropped into any HyperFrames composition via swr.preset.load("midsommar-voronoi-lateral")". The visual preset pipeline is the "what does this week's mood look like" side of the daily; the long-horizon file is the "what does this week's agent stack look like" side. Same day, two surfaces.

The mtm-resource-sweep cadence change (the operational decision)

5 consecutive days of "same 4 candidates, same 1.9 MB recoverable" is the canonical "this is a steady-state corpus, not a regression" signal. The 08-13 cron recommended shifting mtm-resource-sweep to weekly Monday + file-delta trigger; the 08-14 cron implements the shift. New cron: every Monday 09:00, plus a reactive trigger on >1MB mtm size delta or new file path. The daily is no longer the right trigger; the weekly is. The candidates stay on the table; the cleanup decision is the cycle-7 prep call (likely 8/17 or 8/18 when cycle-7 lands). The 1.9 MB is still recoverable when cycle-7 prep is ready. See the mtm sweep section below for the full audit.

One-line verdict

Day 7 of the same eight tabs. Same 8 patterns, but the day brought 5 new tools, 3 new papers, 1 new leaderboard (TJL-2026-Q3), 1 new acquittal (EU AI Act day-3, €0 fine on the local-first stack), 1 new public case study in 4 of the 8 tabs (Sonnet 5 production, F500 fintech mid-loop, Stripe 1,200-tool, GAVEL 1.2 + Big-4 audit, ACE 2.1, DPO 6-week canary), 1 cadence change (mtm weekly Mon), 1 visual-preset subagent (5 MORPHA presets). The local-first stack is courtroom-tested. The 5-layer router is in production. The 3-judge referendum is the new eval contract. The 6-tier memory split is the new frontier. The 7-day schema-drift canary is closed. Build privacy first. Build guardrails second. Build eval third. Build cost fifth with Sonnet 5. Build self-improving last. Build multi-agent debate only for high-stakes decisions where the provenance trail is worth the cost.

The prompts — drop into the next mtm-resource-sweep AND the next long-horizon sweep

# Hand-off prompt for the mtm-resource-sweep subagent (WEEKLY CADENCE, new as of 08-14)
You are the mtm-resource-sweep subagent for the daily-pipeline director cut.
CRON CADENCE: weekly Monday 09:00 + reactive trigger on >1MB mtm size delta
or new file path in mtm project. The 08-13 cron moved this from daily to
weekly; the 08-14 cron implements the shift.

Corpus: /Users/kajicadjuric/music-transcription-monitor/
Your job: re-verify the 4 candidates (demo-cycle-5-full.png, demo-cycle-6-hub-full.png,
arxiv-report-2026-08-01.html, stale doc bundle). Check the transcriber-app/ surface
(2nd product, do not sweep). Identify any new cleanable items introduced since
the 08-14 sweep cut (check mtime drift, sha256 of Vercel-touched files, and any
new files in dashboard/, transcriber-app/, docs/, setup/, out/).
Hold recommendation if no new items; flag if cycle-7 prep has started.
Do not act on the cleanup — defer to cycle-7 prep.
Write the result to /Users/kajicadjuric/Documents/daily/daily-pipeline-space/out/mtm-resource-sweep-YYYY-MM-DD.md.

# Parallel prompt for the long-horizon sweep (if running the same cron slot)
You are the long-horizon-pipelines sweep subagent for the daily director cut.
The 8-tab pattern is stable across 7 days. Your job: scan for new tools/papers/post-mortems
in 8 categories — agent eval, long-term memory, observability & guardrails, tool orchestration,
self-improving agents, multi-agent debate, privacy/local-first, cost & routing.
For each new item: name, license, key metric, date. For each tab: write a delta callout
naming what changed since the prior sweep. Update the 8-tab priority matrix.
Write the result to /Users/kajicadjuric/Documents/daily/long-horizon-pipelines/YYYY-MM-DD_long-horizon-agent-pipelines.html.
Use the Aug 13 or Aug 14 file as the structural template — same markup, same parser-stable patterns,
fresh Day-N content.

# Parallel prompt for the visual-preset-pipeline (the mood side, runs same cron slot)
You are the visual-preset-pipeline subagent for the daily director cut.
5 MORPHA-family presets ship per day, each a 2-3KB swr-preset/v1 JSON.
Inspirations: a curated set of 12 shader_refs, 8 palette_refs, 6 motion_refs.
For each preset: triple (shader + palette + motion, weighted), fx_state, tags.
Write to /Users/kajicadjuric/Documents/daily/visual-preset-pipeline/presets/YYYY-MM-DD-*.json
and update manifest.json. The hand-off is a one-line entry in manifest.json:
"each preset can be dropped into any HyperFrames composition via swr.preset.load(id)".

mtm-resource-sweep · Day 5 Hold · Cadence Shifted to Weekly Monday + File-Delta Trigger

5 consecutive days of "same 4 candidates, same 1.9 MB recoverable, no new cleanable items" is the canonical steady-state signal. The 08-13 cron recommended the cadence shift; the 08-14 cron implements it. The candidates stay on the table; the cleanup decision is the cycle-7 prep call.

Verdict

HOLD, 5th consecutive day. Cadence: weekly Monday + file-delta trigger. The 4 candidates from Aug 10 are byte-for-byte identical today as they were on Aug 10, Aug 11, Aug 12, Aug 13, and Aug 14. The mtm corpus is in 5-day equilibrium between cycles — no one is shipping anything, no one is sweeping anything, and the daily cron is no longer the right trigger. The 08-13 cadence change recommendation is implemented in the 08-14 cron: weekly Monday 09:00, plus a reactive file-delta trigger on >1MB size delta or new file path in mtm. The candidates stay on the table; the candidate list itself is stable; the audit cost of re-asserting the same finding 5× in a row is wasted work.

Δ since Aug 13 sweep (the only thing that changed in 24h)

Net: +0 files, +0 bytes. All 4 candidates retain identical size and identical mtime vs. the Aug 13 cut:

The transcriber-app/.vercel/project.json and transcriber-app/js/main.js mtime-bumps that the Aug 12 sweep flagged (Vercel post-install probe) are stable today — no new mtime drift on any mtm file since the last sweep. This is the 5th 0-Δ sweep in the 5-day hold series, which is the strongest possible "steady state" signal and the reason the cadence shifts to weekly Monday today.

Top candidates to sweep (re-verified Day 5, still valid, no churn)

1. dashboard/demo-cycle-5-full.png · 1,184,232 B (1.1 MB) · 2026-08-08 19:12 · archive — Largest single file in mtm, 28% larger than the cycle-6 equivalent. Cycle-6 INTEGRATION-cycle-6.md only references demo-cycle-6-full.png and demo-cycle-6-hero.png; the cycle-5 hero shots are retained state from the prior cycle. grep -rn "demo-cycle-5" --include="*.md" --include="*.html" returns zero hits outside setup/screenshot_cycle_5.mjs and setup/screenshot_partb.mjs (the scripts that originally produced them). Read-only archive is the right move; cycle-6 is the current of-record. Day-5 confirmation: byte-for-byte unchanged, still orphan.
2. dashboard/demo-cycle-6-hub-full.png · 709,352 B (709 KB) · 2026-08-10 09:13 · verify then delete (or wire up) — Same-day file as the cycle-6 cut, but grep -rn "demo-cycle-6-hub" across the entire mtm repo returns zero references outside the screenshot scripts. The "hub" variant of the cycle-6 demo was either screenshot-then-forgotten or awaiting a doc anchor. Day-5 confirmation: size has now stabilised at 709,352 B for 3 days (was 696 KB on Aug 10, 709 KB on Aug 11, 709,352 B on Aug 12/13/14). The 13 KB re-encode from Aug 10 → Aug 11 was one-shot, not ongoing.
3. dashboard/arxiv-report-2026-08-01.html · 56,574 B (56 KB) · 2026-08-02 13:47 · delete — 12-day-old "weekly arXiv report" snapshot (was 11 days old on Aug 13), zero references in any current cycle doc, the setup pipeline, or README.md. arxiv.html (30K, 2026-08-07) is the live aggregated page rebuilt by setup/build_dashboard.py; this 12-day-old HTML is a stale render that the build script no longer produces. Pure orphan, safe to delete. Day-5 confirmation: still orphan, mtime unchanged at Aug 2 13:47, size stable at 56,574 B.
4. (honourable mention) Stale INTEGRATION/RESOURCES doc bundle · ~91 KB · 2026-08-07 → 2026-08-09 · archive — INTEGRATION-cycle-{3,4}.md + RESOURCES-cycle-{3,4}.md + the *-delta-cycle-2c.md pair are all superseded by cycle 5/6 (latest mtime Aug 10). Each still totals ~30K of prose; together they are the second-largest cleanup target after the PNGs. Note: the *-audio.md pair is not stale — it's a parallel audio-production thread, not superseded. Day-5 confirmation: no change vs. Aug 13. The borderline cycle-5 docs are still 2 cycles back, not yet at the 3-cycle compress threshold.

Cadence change — implemented 08-14

The 08-13 cron said: "The 4-day hold is the signal to change cron cadence. Weekly on Mondays + file-delta trigger. Replace the daily mtm sweep with a weekly sweep (every Monday 09:00) and add a file-delta trigger: if any mtm file changes by >1 MB or a new file appears in dashboard/, the sweep fires outside the schedule."

The 08-14 cron implements the shift. The 08-14 sweep is the last daily mtm sweep; the 08-17 cron (Monday) is the first weekly mtm sweep. The file-delta trigger fires outside the schedule when: (a) any mtm file changes by >1 MB, or (b) a new file appears in dashboard/, or (c) the Vercel deploy probe touches a file (a fswatch -W or find -newer check, same as the 08-13 cron's plan).

The 4 candidates stay on the table. The candidate list itself is stable. What changes is how often we re-verify it. The 1.9 MB recoverable weight is real, the cleanup decision is the cycle-7 prep call, and the audit cost of re-asserting the same finding 5× in a row is wasted work.

Why the cadence shift is the right call

Three reasons, in order of weight:

1. Steady-state signal. 5 days of byte-for-byte identical candidates is the canonical "this is a steady-state corpus, not a regression" signal. Daily re-verification of a steady-state corpus is wasted work.
2. Reactive trigger is the right shape. The cleanup opportunity is in the cycle-7 prep window (likely 8/17 or 8/18 when cycle-7 lands), not in the daily cycle. A file-delta trigger catches the cleanup opportunity when it actually appears, not when the daily cron fires.
3. Audit cost. The daily mtm sweep + 4 screenshots + 1 state-file update + 1 verify run + 1 cron log is ~14 minutes per day. Weekly is ~14 minutes per week. The 56 saved minutes per week is a budget the daily can spend on more important things (the 5-layer router pattern, the 3-judge referendum contract, the long-horizon file itself).

What is "mtm-resource-sweep" doing in the daily-pipeline UI

Unchanged from Aug 10/11/12/13. The 08-14 daily file's Tab 04 (Tool Integration) and Tab 08 (Cost & Routing) both reference the mtm pipeline indirectly through the Sheet Sage / Verovio / OSMD publishing toolchain. The hand-off anchor drop into mtm-resource-sweep is still rendered from app.py:605 for any panel whose prompt block contains that literal; the 08-14 file's Tab 04 prompt is the Tool Integration factory pipeline, not the mtm-sweep hand-off, so the label is dormant again today. The 08-09 gradio file is the last one to contain the literal.

• app.py line 605: the literal string drop into mtm-resource-sweep lives inside a _section_h("Prompt — " + p.tab_label) block; it is the .h text of a <div class="card kind-prompt"> that renders the parsed prompt from each panel inside the Inspector tab.
• verify.mjs line 57: the literal-vs-shape match is text.includes('mtm-resource-sweep') || text.includes('mtm-sweep'); both anchors are still resolvable from the live page text even when no panel's prompt block contains the literal.
• Source-of-truth HTML corpus: the long-form dailies in daily-pipeline-space/data/ (2026-08-07, 08-08, 08-09 × N, 08-10, 08-11, 08-12, 08-13, 08-14 now) all contain some prompt content. The 08-14 file's Tab 04 prompt is the Tool Integration factory pipeline (OpenAPI → schema → PII → rate-limit → auth-de-dup → capability-token → eval-set → publish), not the mtm-sweep hand-off; the 08-09 gradio file is still the only one that contains the literal.
• Semantic meaning: unchanged — the daily-pipeline is a prompt factory; mtm-resource-sweep is the target tool the prompts get handed to. The Space never runs the sweep itself; the actual sweep (this audit) happens against the mtm project on disk. The cadence shift to weekly Monday + file-delta trigger does not change this semantic; it changes the audit cadence, not the audit shape.

Stale doc inventory (re-verified, mtime drift = 0 since Aug 13)