Spokes.wiki Search About

Log — Agentic Tooling Wiki

Append-only history. Each entry starts with ## [YYYY-MM-DD] <op> | <title> where <op> is ingest, query, lint, or split, so grep "^## \[" log.md | tail -5 works.

[2026-07-21] ingest | How to Run Claude Code Agents for 24 Hours (hub-routed, Telegram, URL-only, T3)

TDS (Kjosbakken, 2026-07-20): operator how-to for long-horizon unattended Claude Code. Created source summary run-claude-code-agents-24-hours (BlogPosting, url-only, T3 — hands-on, no data; “eliminate all bugs” review claim unbacked). No new Thing page — the concepts already have homes; folded into existing threads: loop-engineering (review-is-the-bottleneck, stated from the operator’s chair), agent-guardrails + cloud-run-sandboxes (autonomy via sandbox+backup, not trust), agents-never-do-alone (second-agent PR review as throughput unlock), cognition-fable5-through-the-night (this is the practitioner counterpart to that vendor 8h case study). Updated eivind-kjosbakken into a two-axis frame: breadth (orchestrate-100-agents-claude-code) + duration (this). Synthesis loop-section extended. Bridge anthropic (research-wiki). Runner-up: none (platform-ops “always-on remote execution” is too thin to count) — squarely agentic-coding-harness operation.

[2026-07-21] ingest | Writing a Good CLAUDE.md (hub-routed, Telegram, URL-only, T3)

HumanLayer blog (Kyle/@0xblacklight, 2025-11-25): prescriptive guide to authoring CLAUDE.md. Created source summary writing-a-good-claude-md (BlogPosting, url-only, T3 — named agent-eng shop, research-grounded but unbenchmarked opinion). New Thing page claude-md (DefinedTerm/convention) — the file was previously only an alias inside other pages; this is the first source about the file itself, so it earns a node (Claude-native sibling of agents-md). Two mechanisms recorded that the context-rot thread didn’t state: (1) Claude Code’s system prompt tells the model to disregard context it deems irrelevant, so non-universal CLAUDE.md instructions silently get skipped; (2) a ~150–200-instruction ceiling with uniform degradation — making minimization a compliance move, not just token-budget. Folded both into context-rot and synthesis. Contradiction flagged: its never-auto-generate stance vs. the docs-as-build-artifact pole (openwiki, autowiki-factory) that CI-writes CLAUDE.md/AGENTS.md — logged as an open tension in synthesis. Entities: humanlayer (Organization, 12-factor-agents), kyle-0xblacklight (Person, thin). Bridge anthropic (research-wiki). Runner-up: research-wiki (tools-for-thought) — declined; CLAUDE.md is an agentic-coding-harness config artifact, squarely this spoke.

[2026-07-19] ingest | Claude Code weekly-limits promotion (hub-routed, Telegram, URL-only, T2)

Anthropic support notice: a temporary +50% boost to Claude Code’s weekly usage cap, May 13–Aug 19 2026, auto-applied to Pro/Max/Team/legacy-seat-Enterprise (Free + consumption-Enterprise excluded); scoped to Claude Code across CLI/IDE/desktop/web; 5-hour limits untouched. Ephemeral T2 first-party doc. Created source summary claude-code-weekly-limits-promo (WebPage, url-only). No new Thing page — folded into the existing harness-as-product cost/UX thread in synthesis as the inverse of the tighter-limits friction: the durable takeaways are the two-tier limit (5-hour window + weekly cap) and the weekly cap as the vendor’s adjustable lever (subscription limits = managed surface, not fixed spec). Cross-linked anthropic-agent-sdk-billing-pause, claude-apps-gateway (enterprise spend-cap counterpart), boris-cherny, claude-agent-sdk. Entity anthropic (bridge, research-wiki). Runner-up: llm-providers-wiki (usage-limit/pricing facet) — declined; this is Claude Code product policy, not the model-API market.

[2026-07-09] ingest | Claude Code: model vs effort level (hub-routed, Telegram)

Anthropic explainer (claude-code-model-effort-levels, T1) separating two controls Claude Code users conflate: model = which frozen weights (capability ceiling; context steers, never retrains) and effort = how much work the agent does (files read, tools, steps, verification before “done”). Corrects the folk model that effort is just thinking time — it scales the whole loop, and raising it does move token-generation (switching models doesn’t). Diagnostic split: too-little-work (skipped files/tests) → raise effort; confidently-wrong-with-good-context → upgrade the model. New Thing page effort-level (DefinedTerm/mechanism) — first source to name effort as a first-class harness control distinct from model selection; folded into synthesis item 3 (the loop/verification thread — effort is the productized single-knob form of loop-engineering/agent-loops-verification). Back-linked from claude-code-best-practices (which had only the model axis). Cross-spoke context noted, not fragmented: the model-tier market (Fable/Opus/Sonnet) is llm-providers-wiki; the frozen-weights/steering mechanics touch llm-inference-wiki — dominant substance (harness control) stays here. index updated.

[2026-07-08] ingest | ask-search (ythx-101) — self-hosted zero-key web-search skill (hub-routed)

MIT skill giving agents web search with no API key: wraps self-hosted SearxNG (70+ engines) behind an MCP server + CLI + an OpenClaw SKILL.md; Tavily API optional fallback; targets Claude Code/OpenClaw/ Antigravity. Ingested as ask-search (T1, young, no independent eval). Extends the local-first-tool- over-MCP corner from memory (recall) / documents (knowledge-rag) / perception (watch-skill) to live web search — same delivery shape, fourth capability. Framed as the free/private counterpart to from-local-llm-to-agent‘s paid Tavily grounding tool (“skills × MCP = agency”, tool side self-hosted). Reciprocal link added to knowledge-rag; synthesis (layer-6 local-first corner) + index updated. Runner-up search-marketing-wiki declined — this is a web-search tool for agents, not SEO/PPC/AI-search market. Entity discovery: author ythx-101 thin single-repo handle — inline mention, no node. Hub route entry to follow.

[2026-07-08] ingest | watch-skill (oxbshw) — video-watching + self-verification skill (hub-routed)

MIT skill giving any coding agent (1) video understanding and (2) self-verification. Ingested as watch-skill (T1, young ~113★, self-reported metrics). Pipeline: PySceneDetect+phash frames, RapidOCR, offline faster-whisper, SQLite/FTS5 + ONNX-embedding hybrid index; delivered over MCP (13 tools) + CLI + REST across ~8 hosts. “THE LOOP” = record own output → structured critique vs pass criteria → fix → re-verify → before/after proof GIF: this is the spoke’s output-grounded verification (ai-job-search, loop-engineering) pushed into a new modality (watch the rendered video, not read the rendered PDF) and, unlike ai-job-search’s in-repo loop, shipped as a reusable cross-harness skill. Also sits on the knowledge-rag/recall local-first-store-over-MCP shape, extended from text/memory to perception. Reciprocal links added to loop-engineering + ai-job-search; synthesis (layer-3 verification thread)

  • index updated. Cross-spoke: embeds STT (faster-whisper) — faint speech-audio-wiki adjacency, noted not routed (subject is the agent capability, not the STT model). Entity discovery: author oxbshw is a thin single-repo handle — inline mention, no node. Hub route entry to follow.

[2026-07-08] ingest | GitHub-repo burst: agent-scripts + openwiki + pxpipe (hub-routed)

Three GitHub repos arrived together via Telegram, all pre-routed here by the hub router; each extended an existing thread rather than opening a new one, so no spin-out.

  • agent-scripts (steipete) — Peter Steinberger‘s personal cross-harness hub of skills + AGENTS.MD hard rules + helper scripts (sync-skills mirrors into Codex & Claude Code, validate-skills, committer). T1. The individual-developer floor of the skill-infra spectrum (vs superpowers/pm-skills packs-for-others; vs autoharness‘s automated maintenance). Entity discovery: created the peter-steinberger Person node (OpenClaw creator → OpenAI; previously inline only in openclaw/openclaw-hermes-control-layer). Folded into synthesis layer 1.
  • openwiki (langchain-ai) — OSS CLI that auto-generates + CI-refreshes codebase docs for agents, appending to AGENTS.md/CLAUDE.md. T1. Second instance of docs-as-build-artifact next to autowiki-factory (closed product ↔ OSS CLI). Owner = existing langchain node (added the doc-gen facet). Cross-wiki seam to research-wiki’s llm-wiki. Folded into synthesis layer 6.
  • pxpipe (teamchong) — local proxy cutting Claude Code token cost ~59–70% by rendering dense context as PNGs (image tokens priced by pixel area). T1, self-reported eval. Modality-arbitrage pole opposite headroom in the pre-model compression corner; new tokenmining lever. New tension logged: irreversibly lossy on byte-exact strings, and worse on stronger models (0/15 Opus) — added to Contradictions. Cross-spoke seam (image-token pricing/OCR) to llm-inference-wiki + llm-providers-wiki.

teamchong left a thin inline mention (single repo, no node yet). Cross-links added to headroom, autowiki-factory, langchain, openclaw. Index + synthesis updated. Hub route entries to follow.

[2026-06-15] ingest | ArrowJS — arrow-js.com

Reactive UI framework positioned as “for the agentic era”: three functions (reactive, html, component), plain TypeScript, no build step, under 5 kb. Key feature: WASM sandboxing — component logic runs inside a WebAssembly sandbox while rendering to the DOM, so a chat agent can hand generated UI code to a host app safely. T1 (official project site). Entity discovery: no named author in the source; no new entity pages. Gap closed: first source in the spoke addressing the rendered output layer (what agent-generated UIs look like). WASM sandbox maps to agent-guardrails’ containment discipline applied to the browser. Runner-up webperf-wiki (< 5 kb / no build step); noted in source page. Synthesis updated (new “rendered output layer” section). Index updated. Hub route entry to follow.

[2026-06-01] split | agentic-tooling-wiki created from research-wiki’s cluster B (human directive: “Migrate”)

A single Telegram burst added ~10 agent-tooling sources to research-wiki’s “cluster B” (agentic LLM products / skills / orchestration / harnesses), making it the largest body in that wiki. The hub router flagged this and recommended a spin-out; the human approved (“Migrate”). Carved cluster B into this dedicated spoke.

Migrated 24 wiki pages from research-wiki:

Bridge nodes left in research-wiki (cluster-A core / substrate), linked cross-wiki from here: gbrain (knowledge-management core), agent-skills (the procedural↔knowledge bridge concept), compound-engineering (Engelbart bootstrapping), model-context-protocol (shared A/B substrate), anthropic + claude-opus-4-8 (model substrate), garry-tan. Authored this spoke’s synthesis (skills → harness → orchestration/deployment thesis) and index. Spoke count 6 → 7.

[2026-06-01] lint | post-split health check

First lint after the split. Findings + fixes: (1) provenance nit — 6 concept/derived pages listed URL-only source slugs in sources: (which is for raw docs); corrected to raw-only (agent-orchestration, spec-driven-development keep their one raw doc; adk, agentskills-spec, google, agentic-coding-harness → sources: [], provenance via inline links). (2) Stale terminology — removed research-wiki-internal “cluster A/B” labels from ~16 spots across the migrated pages and reworded 3 placement notes (agentic-seo-skill, claude-to-speech, spec-driven-ai-tools) to the new spoke’s framing. (3) Orphans: none. (4) Cross-wiki links verified resolving (link check passes). No contradictions found.

[2026-06-01] ingest | Agents That Build Agents: SKILL-first Blueprint (Microsoft) — honest stub

Routed in by the hub. Fetch failed (JS-rendered MS Community Hub → title only); recorded an honest stub per the fetch-fail rule, specifics flagged unconfirmed. Created agents-that-build-agents-ms (BlogPosting, source) + microsoft (Organization, tracked lightly). Significance: Microsoft becomes the third major vendor (after anthropic, google) on a skill-first agent framework — folded into synthesis Vendors as “three independent vendors converging on skills as the primitive,” with the open question of whether MS adopts agentskills-spec or fragments. Refresh on a successful re-fetch.

[2026-06-01] ingest | oh-my-pi (omp) — IDE-wired terminal coding agent

Routed in by the hub (clear match, no runner-up). Created oh-my-pi (SoftwareSourceCode): a feature-rich terminal coding agent (fork of Mario Zechner’s Pi) — hash-anchored edits (~61% token reduction, claimed), 32-tool harness with in-process Rust tools, LSP integration + first-class debuggers, persistent Python/JS kernels, Puppeteer browser, structured-JSON subagents, 40+ providers, MIT. Placed at the IDE-integrated/feature-rich end of agentic-coding-harness (vs claw-code minimal); updated that concept’s instance list + spectrum. Reinforces “harness competes on engineering depth, not prompts” and provider-agnosticism (cross-links llm-provider in llm-providers-wiki). Caveat: README claims, unbenchmarked.

[2026-06-01] ingest | Long-running AI agents that pause/resume with ADK (Google)

Routed in by the hub (clear match; existing adk page). Created adk-long-running-agents (BlogPosting) + new concept durable-agents (long-running pause/resume: state machines over conversation history, persistent sessions via DatabaseSessionService, webhook-driven resumption, human-in-the-loop pauses). Updated adk (now spans skills and durable execution) and synthesis (added durability as a 4th maturation axis; reframed the deployment axis as durable-pause/resume [ADK] vs. continuous-heartbeat [OpenClaw]). Linked to agentsys/gstack persistent state. Caveat: vendor tutorial.

[2026-06-01] ingest | Hermes Agent (Nous Research) — self-improving autonomous agent

Routed in by the hub (clear match). Created hermes-agent (SoftwareSourceCode) + new concept self-improving-agents (closed learning loop: agents authoring/refining their own skills + accumulating memory — the “growth” axis). A convergence node: skills (agentskills-spec- compatible) + agent-orchestration (subagents) + durable-agents (hibernation, persistent memory) + self-improvement; 200+ models (llm-provider), MCP, multi-platform. Explicit OpenClaw successor (imports OpenClaw memories/skills) → advances the self-driven pole of claude-code-channels-vs-openclaw. Bridges to research-wiki: compound-engineering inside the agent, and gbrain (which already cites “Hermes agent deployments”). Updated durable-agents

  • synthesis (added self-improvement as a 5th theme/growth axis). Caveat: README claims.

[2026-06-01] ingest | Spec-driven & framework burst (spec-kit, get-shit-done, Jaseci, node-js skill)

Four agentic-tooling sources routed in together:

  • spec-kit (GitHub, SoftwareSourceCode) — reference SDD toolkit (/speckit.* commands, 30+ agents).
  • get-shit-done (GSD, SoftwareSourceCode) — Claude Code context-engineering + SDD system.
  • jaseci (SoftwareSourceCode) — Jac language + AI framework: Meaning Typed Programming (compiler builds prompts from typed signatures) + graph walkers for agentic workflows.
  • node-js-functional-patterns-skill (SoftwareSourceCode) — a skill via MCP Market; fetch 429’d → honest stub; notable mainly for the skills-marketplace distribution angle (rhymes with Hermes’ Skills Hub + agentskills.io). Updated spec-driven-development with spec-kit (canonical, tool-agnostic) + GSD (context-eng). Jaseci adds a language-level design point (type system as the model interface, vs markdown skills). Caveats: README/marketing; node-js skill unconfirmed.

[2026-06-03] ingest | Microsoft launches Scout (OpenClaw-inspired assistant)

Routed in by the hub. Created microsoft-scout (NewsArticle): Microsoft 365 AI assistant built on the OpenClaw framework — autonomous/always-on (claude-code-channels-vs-openclaw self-driven pole), persistent identity + memory (durable-agents), learns skills/memories (self-improving-agents), prebuilt + custom agent-skills, and a “policy conformance” continuous-audit governance layer. Significance: OpenClaw is now forked (hermes-agent) AND productized (Scout) → the self-driven personal-assistant pattern goes mainstream, with governance as a product feature. Updated microsoft (two agent plays: Agent Framework + Scout) and synthesis (self-driven pole going mainstream). Caveat: launch coverage, early-access.

[2026-06-03] lint | hub-wide health check (fixes landed here)

Part of a hub-wide lint. Fixed 2 orphans: jaseci now linked from agentic-coding-harness (language-level adjacency) and node-js-functional-patterns-skill from agentskills-spec (skills-as-packages/marketplace note). Tidied microsoft frontmatter comment (removed [[ ]] from the YAML comment that tripped the sources-nit check). No contradictions found here.

[2026-06-04] ingest | How to Build a Custom Agent Harness (LangChain blog)

Hub-routed (Telegram). New source summary langchain-custom-harness (BlogPosting, url-only). LangChain’s agent = model + harness how-to. Two contributions: (1) the cleanest statement of the core thesis — “task-harness fit determines agent usefulness more than raw model capability”; (2) a concrete mechanism the wiki was missing — agent-middleware: single-concern pieces that hook the agent loop (before/after model & tool calls, startup/teardown) and compose/stack rather than forming a monolith. Four levers (deterministic logic, tool lifecycle, custom state, stream handlers) + a prebuilt catalog (summarization, context-editing, memory, subagents, retries, PII, human-in-the-loop, prompt caching). Frameworks named: create_agent, Deep Agents, Claude Agent SDK, Pi.

New pages: agent-middleware (DefinedTerm — the structural primitive) and langchain (Organization — fourth agent-platform vendor, distinct in leading with middleware-as-primitive vs the skills-as-primitive of google/microsoft). Substantially updated agentic-coding-harness (added the model + harness formula, task-harness fit, and a new “structural unit” section mapping LangChain’s middleware onto existing threads) and synthesis (layer 2: middleware as the named structural unit + “harness = middleware stack over orchestration/durability/supervision/skills”; Vendors: added LangChain + the skill-vs-middleware primitive tension). Cross-linked Pi→oh-my-pi. Index updated (new DefinedTerm, BlogPosting, Organization rows). No contradictions — reinforces the central thesis.

[2026-06-04] ingest | OpenHuman — local-first personal AI agent (GitHub)

Hub-routed (Telegram); runner-up spoke research-wiki. New source/Thing page openhuman (SoftwareSourceCode, url-only). A GPL-3.0 (~30.7k★) Tauri desktop personal AI agent (Rust/TS), explicitly positioned vs claude-cowork / OpenClaw / hermes-agent — a third entrant on the self-driven autonomous-assistant pole (claude-code-channels-vs-openclaw) after hermes-agent and microsoft-scout, distinguished by local-first / privacy: on-device SQLite, optional Ollama, and a “Memory Tree + Obsidian wiki” knowledge base (Karpathy-inspired) — i.e. a gbrain-style (cross-wiki) personal KB as the agent’s memory. Other features: 118+ OAuth integrations via Composio w/ 20-min auto-fetch; full coder toolset (also an agentic-coding-harness); TokenJuice ~80% context compression; model routing; voice (ElevenLabs TTS, cf. claude-to-speech); meeting mascot.

Updated synthesis (layer 3 self-driven pole: added OpenHuman as the local-first/privacy corner + “this pole sits astride the research-wiki seam”) and back-linked microsoft-scout (lineage line + Related). Index: new SoftwareSourceCode row. Routing note: genuine two-spoke straddle — primary here (it’s an agent harness/assistant benchmarking itself against this wiki’s residents), runner-up research-wiki (the memory-tree/obsidian-wiki tools-for-thought angle); resolved per HUB.md “pick the most specific, note the runner-up,” with the KB angle carried via the gbrain cross-wiki bridge. Reinforces the existing self-driven thread; no contradictions. Caveat: README/landing claims, Early Beta, unbenchmarked.

[2026-06-04] ingest | Anthropic’s ant CLI hands-on (Medium)

Hub-routed (Telegram). New source summary ant-cli (Article, url-only). ant is Anthropic’s first-party CLI for the claude-managed-agents lifecycle: create → deploy to Anthropic’s cloud → send tasks → pull execution traces, “without creating any wrapper code” — collapsing prior REST/SDK boilerplate into terminal commands. Front-ends the April-2026 Managed Agents /v1/agents surface (agents carry config incl. model selection). Author’s framing matches our vendor thesis: “Anthropic moving from model provider to full agent platform.”

Updated claude-managed-agents (added a “Terminal client — ant CLI” section; it now has a second source beyond the FSI README; bumped date + Related) and synthesis (Vendors para: the ant CLI as the developer-facing edge of Anthropic’s model-provider→platform shift). Index: new Article row. Fetch caveat: Medium truncated mid-article — full command set + the “four core concepts” + detailed limitations not recoverable; recorded an honest stub on specifics (lifecycle & positioning are solid). Single practitioner review, unbenchmarked. No contradictions.

[2026-06-04] ingest | What AI Agents Should Never Do on Their Own (Towards Data Science)

Hub-routed (Telegram). New source summary agents-never-do-alone (Article, url-only). Thesis: autonomy is only useful when bounded; the organizing lens is reversibility / recovery cost (high autonomy where mistakes are cheap to undo; human checkpoints where irreversible). Six hard-stop categories (destructive file ops, DB writes/migrations, cloud infra, prod deploys, auth/security logic, secrets). Mechanisms: AGENTS.md contract, blocked_commands.md explicit block list, two-agent implementer/egoless-reviewer loop, final reports, human-reserved deploy timing.

New concept page agent-guardrails (DefinedTerm) — names/operationalizes the governance/ reliability discipline that recurred but had no home: it ties together microsoft-scout‘s policy-conformance audit, hermes-agent‘s command-approval, and the harness review/eval discipline into a permission matrix keyed on reversibility. Positioned as the explicit counterweight to the autonomy push of durable-agents / self-improving-agents. Updated synthesis (layer-3 governance sentence now points to the named framework) and agent-orchestration (the two-agent adversarial-verification pattern doubles as a safety gate). Cross-links: AGENTS.md↔spec-driven-development constitution, human-in-the-loop↔agent-middleware/agent-kanban. Index: new DefinedTerm + Article rows. Caveat: single practitioner op-ed, unbenchmarked. No contradictions.

[2026-06-08] ingest | ai-job-search — Claude Code job-application framework

Hub-routed (Telegram, GitHub; tracking params stripped from URL). New source ai-job-search (SoftwareSourceCode, url; Mads Lorentzen, MIT). A fork-and-customize Claude Code harness for the whole job-application lifecycle: slash commands (/setup, /scrape, /apply, /expand, /upskill), skills (.claude/skills/ core job-application-assistant + job-scraper + upskill; .agents/skills/ TS/Bun Danish-portal CLIs), CLAUDE.md as master profile, and a drafter–reviewer subagent loop in /apply (reviewer independently researches + critiques → drafter revises). Notable patterns: output-grounded verification (compile LaTeX → read rendered PDF → fix layout until visual inspection passes), relevance-weighted CV cutting, token-efficient reviewer dispatch. Significance: the skills+harness+orchestration pattern generalizing to a non-coding vertical. Cross-linked to agentic-coding-harness, agent-skills, agentskills-spec, agent-orchestration, agents-never-do-alone, anthropic; folded into synthesis (layer 2, non-coding vertical + artifact-verification). Index updated. Caveat: author’s README, no independent eval; Denmark-focused scraping.

[2026-06-09] ingest | lathe — skills that teach you (anti-automation augment pole)

Hub-routed (Telegram, GitHub). New source lathe (SoftwareSourceCode, url; Deven Jarvis, MIT). A Go CLI that runs as skills inside Claude Code/Cursor/Codex (/lathe, /lathe-extend, /lathe-verify, /lathe-ask, /lathe-tag, /lathe-voice) to generate hands-on technical tutorials you work through by hand, served at localhost:4242 — “LLMs to teach you, rather than think for you.” Significance: same skill primitive as the rest of the spoke, used for the opposite goal — the extreme augment pole of the augment→automate axis (deliberately keeping the human doing the work), a pedagogical sibling of agent-guardrails/agents-never-do-alone and the agent-tooling instance of Engelbart’s augmenting-human-intellect (research-wiki, cross-wiki). Folded into synthesis (layer 3, after guardrails: “skills are pole-agnostic”); index updated. Caveat: solo “experiment,” README-only. agentic-tooling-wiki 44 → 45 pages.

[2026-06-09] ingest | pm-skills (PM Skills Marketplace) — skills generalize to product management

Routed here by the hub router (Telegram). pm-skills is a marketplace of agent-skills for product managers — “100+ agentic skills, commands, and plugins” (68 skills / 9 plugins / 42 chained workflows; MIT; Paweł Huryn; ~13.3k★). Three artifact types: skills (PM-task knowledge/workflows), commands (slash workflows that chain skills → lightweight agent-orchestration), plugins (by PM domain: Discovery/Strategy/Execution/Launch/Growth/Market Research/Data Analytics/Toolkit/AI Shipping). Primarily Claude Code/Cowork plugins, but cross-vendor (Codex native; exported to Gemini CLI/Cursor/Kiro) — a real stress test of the portable-skill thesis. Folded into synthesis layer 2 as the productized case of skills-beyond-coding (sibling of ai-job-search, lathe); index updated. Caveat: README/marketplace-page only, counts as advertised. Cross-spoke context only (Growth/GTM → search- marketing; PM discovery → research-wiki). agentic-tooling-wiki 45 → 46 pages.

[2026-06-09] ingest | +2 AGENTS.md + Claude Agent SDK — all-spokes cron test

agents-md (DefinedTerm, src — open project-context convention; 60k+ repos, cross-tool, Linux Foundation; the context-standard counterpart to agentskills-spec) and claude-agent-sdk (SoftwareApplication, src — Anthropic’s official SDK = the Claude Code harness as a library; tools/loop/ hooks/subagents/MCP/sessions/skills; the Client-SDK→Agent-SDK→Managed-Agents ladder). Both deepen existing threads (open standards; model-vendor→agent-platform). url-only. 46 → 48 pages.

[2026-06-10] ingest | SeekDB (OceanBase) — the agent memory/state substrate as a product

Hub-routed (Telegram, GitHub; tracking params stripped). New source seekdb (SoftwareSourceCode, url; OceanBase, Apache-2.0) — “the AI-native state store for agents”: MySQL-compatible, embedded or server, hybrid vector + full-text search in one SQL query, immediate write→read (async index pipeline + two-level HNSW), full ACID, and the distinctive copy-on-write FORK/MERGE sandboxes (branch agent state, explore, merge/rollback). Drops in under LangChain/LlamaIndex/Dify via the MySQL wire protocol. Significance: the spoke’s memory layer, until now always inside a harness (openhuman Memory Tree, durable-agents state, self-improving-agents accumulation, gbrain cross-wiki), shows up for the first time as a standalone infrastructure product — a separate vendor stratum (a proven DB team, not an agent-platform vendor) competing to be the substrate harnesses run on. The FORK/MERGE primitive = the storage-layer expression of the reversibility/exploration discipline in agent-guardrails. New concept agent-memory (DefinedTerm — names the state + retrievable-knowledge layer of its own) and light maker org oceanbase. Folded into synthesis (new “memory/state substrate becomes a product” section) + index (DefinedTerm/SoftwareSourceCode/ Organization rows). Runner-up research-wiki (the agent-memory/RAG angle) carried via the gbrain bridge, not duplicated — same handling as openhuman. Caveat: 10×-Milvus throughput is the repo’s own benchmark, unreplicated. 48 → 51 pages.

[2026-06-12] ingest | A2A (Agent2Agent protocol) — a2a-protocol.org

All-spokes daily expansion. Added a2a-protocol (@type WebAPI) — the inter-agent protocol completing the standards layer (skills agentskills-spec / context agents-md / tools MCP

  • now agent↔agent interop). Google-originated, donated to the Linux Foundation; Agent Cards (capability discovery), tasks with streaming/async delegation, JSON-RPC/HTTP; cross-vendor (LangGraph/ CrewAI/ADK/custom) without exposing internal memory/logic. Cleanest framing: MCP = agent→tool, A2A = agent→agent (complementary). Promotes agent-orchestration from in-process to a cross-vendor wire format; sharpens the standardization-reach open question (4 standards = attractors or fragmentation; ACP + vendor-native coexist). synthesis note added; index WebAPI group updated. 1 new page. Authoritative (the protocol’s own spec site / Linux Foundation).

[2026-06-12] ingest | Hermes Agent Profile Builder (Nous Research, via MarkTechPost)

Telegram drop, routed → agentic-tooling-wiki. Quality gate (first source under the new mechanism): tier T3 (MarkTechPost trade-press; Nous repo would be the T1 primary — weakness recorded, ingested per the soft gate); dedup → hermes-agent already exists, so added a distinct source page hermes-profile-builder for the new tool (not a re-seen refresh) + folded a section into hermes-agent; gap-relevant (advances the standardization-reach + agent-as-composition threads); freshness: volatile (fast-moving product). Substance: a local web dashboard (127.0.0.1:9119) composing an agent from 4 blocks — identity / model+provider / skills / MCP servers — writing config.yaml/.env/SOUL.md with CLI parity; open-source (pip install 'hermes-agent[web]'). Synthesis note “agent = composition gets a GUI”; index + hermes-agent updated. 1 new page.

[2026-06-14] ingest | renwei-writing (人味儿写作) — github.com/orange2ai/renwei-writing

Routed from hub (Telegram drop). An AI agent skill (SKILL.md + post-edit-checklist + case-study, progressive disclosure) for editing text without erasing the author’s voice — packaged for the Cola framework (~/.cola/skills/). Quality gate: tier T1 (first-party project repo); not previously paged → new source summary renwei-writing. Gap-relevance: (1) extends the augment pole (lathe) to writing — same skill primitive, anti-homogenization use; (2) new standardization-reach data point (Cola = another host with a SKILL.md-style dir). Integrated surgically into synthesis (augment-pole thread + standardization open question); no new “Added” section, to avoid drift. freshness: stable. url provenance. Site rebuild + commit follow.

[2026-06-14] ingest | anthropics/skills — official Agent Skills repository (github.com/anthropics/skills)

Routed from hub (Telegram drop). Anthropic’s official public Agent Skills repo: the spec (./spec/), a template, example skills + the source-available document skills (docx/pdf/pptx/xlsx) that power Claude’s production file handling, and a Claude Code plugin marketplace. Quality gate: tier T1 (first-party project repo); not previously paged → new source summary anthropic-skills. Gap-relevance: the canonical first-party home of the agentskills-spec standard — a strong counterweight on the standardization-reach open question (a major vendor authoring + shipping the spec, not just adopting it). Threaded into agentskills-spec (new “canonical first-party home” section) + synthesis (standardization thread). freshness: stable (repo identity durable; star count noted as a dated snapshot, not load-bearing). Site rebuild + commit follow.

[2026-06-14] dedup | Google — removed duplicate page (now a cross-wiki bridge node)

Deleted the local google.md (a thin agent-vendor facet duplicating the real-world entity). Google is now a single canonical node in llm-providers-wiki, linked cross-wiki; index.md moves it to Bridge nodes. The agent-platform-vendor substance is preserved on the canonical node + in synthesis. Closes the entity-index audit’s flagged duplicate.

[2026-06-14] ingest | tgpt — AI chatbots in the terminal (github.com/aandrew-me/tgpt)

Routed from hub (Telegram drop). A cross-platform Go CLI (GPL-3.0) that fronts ~10 LLM backends from a shell prompt — a multi-provider chat frontend, not an agent (no tool use / file edits / planning loop). Quality gate: tier T1 (the project’s own README + providers.md); not previously paged → new source summary tgpt. Gap-relevance: a boundary marker — the non-agentic, prompt→reply floor of the terminal-AI ecosystem (beneath claw-code / oh-my-pi / Gemini CLI), reinforcing by contrast the spoke’s “value is in the structure” thesis. Backends link the existing cross-wiki provider nodes (openai, deepseek, Gemini); Groq/Ollama/MiniMax/Pollinations/KoboldAI/Isou/Arta left unpaged (evidence-only entity rule). Cross-spoke: runner-up llm-providers-wiki — tgpt is really an access-layer artifact over the model market (free + paid + open-weight access in one CLI); noted in the source page + synthesis, not split. Threaded into synthesis (new boundary-marker note) + index. freshness: stable. url provenance. Site rebuild + commit follow.

[2026-06-15] lint | agents-that-build-agents-ms — stub upgraded; spec-adoption question resolved

Quality cycle: the founding community-hub source is JS-gated (still un-fetchable), so rebuilt agents-that-build-agents-ms from fetchable companions — the authoritative Microsoft Learn doc Use skills with Microsoft Foundry agents + the author’s ITNEXT cross-post (found via WebSearch). Resolves the synthesis open question: Microsoft Foundry skills “follow the Agent Skills specification format” (agentskills.io) — SKILL.md + YAML front matter, progressive-disclosure advertise→load→read via AgentSkillsProvider, surfaced to any MCP client as MCP Resources (SEP-2640), plus a versioned Foundry Skills REST API. So Anthropic + Google + Microsoft converge on the same open format wired to MCP — convergence, not fragmentation. Documented the build-time/run-time two-layer architecture (Coding Agent authors SKILL.md → Runtime Agent runs it). Updated synthesis (Standardization open question + Vendors paragraph); page ret(ained) BlogPosting/T3, url unchanged (Learn doc cited inline).

[2026-06-15] ingest | Loops replace prompts; verification as the bottleneck (hub-routed)

Hub-routed Telegram drop (agent-loops-verification, The New Stack, Arjun Iyer/Signadot, 13 Jun). The New Stack body is JS-gated (third time this session); substance recovered via WebSearch + the surrounding TNS/Signadot article cluster. Thesis: agentic coding shifts prompt→loop (loop-engineering; Ralph technique generalized), relocating the bottleneck from generation to verification — and “feedback is only as truthful as the system that generates it,” so for cloud-native code verification is a runtime problem (validate against a real system). New pages: agent-loops-verification (TechArticle, T4 — trade press + vendor-authored), loop-engineering (DefinedTerm), signadot (Organization, the ephemeral-environment vendor), arjun-iyer (Person, author/CEO). Threaded into synthesis layer 3 (verification now a first-class layer; output-grounded verification + guardrails matter MORE as loops outpace review) + cross-spoke adjacency (new platform-ops verification-runtime seam, noted bidirectionally in platform-ops/synthesis.md). Tier T4: body JS-gated, vendor-interested (Signadot sells the fix) — problem-framing kept, product treated as one data point; T1/T2 upgrade = a neutral study of loop-driven verification rates. Cross-spoke runner-up: platform-ops-wiki (cloud-native runtime substrate).

[2026-06-15] lint | microsoft org page — stub upgraded (Foundry + Agent Framework)

Resolved the honest-stub on microsoft (founding source body never fetched). Enriched from Foundry/Agent Framework public docs (via WebSearch): Microsoft Foundry = unified “agent factory” platform (Foundry Agent Service, Foundry IQ = evolved Azure AI Search, Foundry Toolkit for VS Code, control-plane governance, multi-agent orchestration + A2A APIs, Semantic Kernel/AutoGen/ CrewAI support); Microsoft Agent Framework = the open-source agent SDK beneath it. De-hedged the former “does MS adopt the spec?” open question — resolved (adopts agentskills.io + MCP Resources, per the upgraded agents-that-build-agents-ms). Removed the stub warning; index entry refreshed. No longer a stub.

[2026-06-16] ingest | awesome-hermes-usecases (hub-routed, Telegram) — evidence counterweight + Nous node

Routed in as a clean single-spoke match (Hermes Agent already paged here). Added awesome-hermes-usecases (SoftwareSourceCode, source:true, T2 — community-curated by aliaihub, per-entry primary-source rule)

  • new entity nous-research (Organization, the owner/developer common to hermes-agent/profile-builder). Gap-relevance: it’s the evidence counterweight to hermes-agent‘s standing README-claims caveat — third-party, primary-source-gated deployment catalog across 13 domains; softened that caveat in place and named the self-improvement mechanism (GEPA + DSPy) the README abstracts away. Folded into synthesis “Benchmarks” open question as a partial step (usage evidence, not a benchmark). Dedup: hermes-agent / hermes-profile-builder refreshed in place, not duplicated. +2 pages.

[2026-06-16] ingest | autonovel (hub-routed, Telegram) — Hermes Agent flagship deployment + loop instance

Second Hermes-orbit source today. Added autonovel (SoftwareSourceCode, source:true, T1 first-party Nous repo) — an end-to-end autonomous novel pipeline orchestrated by hermes-agent: 4 phases / ~27 scripts, quality-gated loops (>7.5 / >6.0 / plateau detection), an Opus review loop, and a dual-”immune-system” feedback signal (mechanical regex scan + separate LLM-judge). Concrete artifact: a 79,456-word novel. Gap-relevance: strongest first-party evidence for Hermes’ deployed capability (softened the README-claims caveat on hermes-agent further) AND a vivid worked instance of the loop-engineering/agent-loops-verification “verification is the bottleneck” thesis — folded into that synthesis thread. Model-agnostic note recorded: “by Hermes Agent” but runs Claude Sonnet/Opus + fal.ai + ElevenLabs (Hermes = conductor). Entity discovery: no new nodes — nous-research paged earlier today; Anthropic/claude-opus-4-8/Karpathy exist cross-wiki; fal.ai + ElevenLabs incidental deps (skip). Cross-linked into hermes-agent / awesome-hermes-usecases / nous-research. +1 page.

[2026-06-16] ingest | autoresearch (hub-routed, Telegram) — the loop paradigm’s origin + feedback-signal contrast

Third loop-instance source today; the origin of the autoresearch paradigm autonovel credits. Added autoresearch (SoftwareSourceCode, source:true, T1 first-party Karpathy repo) — his “agentic scientist” PoC: agents edit train.py only → 5-min training → measure val_bpb → keep/discard, ~100 overnight runs. Gap-relevance: it’s the cleanest loop-engineering/agent-loops-verification instance AND sharpens the thesis by contrast with autonovel — autoresearch has an objective metric (val_bpb) so autonomy is near-free; autonovel had to engineer a feedback signal (LLM-judge) because prose has no ground truth. Folded that contrast into the loop synthesis thread; also reframed containment (edit-only-train.py, reviewable diffs) as an autonomy enabler. Cross-linked autonovel↔autoresearch. Cross-spoke: Karpathy is a research-wiki node (andrej-karpathy) — linked the bridge, ingested here per the agent-tooling split (research-wiki = runner-up). Entity discovery: no new nodes (Karpathy exists cross-wiki; nanochat = incidental infra, mentioned inline). +1 page.

[2026-06-16] ingest | second-son-house-of-bells (hub-routed, Telegram) — the autonovel artifact, reader-facing

Fourth Hermes-orbit source today, and the output end of the autonovel thread: the published novel’s own landing page (nousresearch.com/bells). Added second-son-house-of-bells (Book, source:true, T2 — first-party but promotional landing page; softer than the autonovel repo, T1). Deliberately NOT a refresh of autonovel: that page is the pipeline/repo, this is the artifact (the Cantamura world where “the law is sung,” protagonist Cass Bellwright, three distribution formats). Kept the pipeline stats on autonovel and the reader-facing framing here; cross-linked both ways. Notable: the byline “Claude Hermes” — the agent given a named authorial identity (Hermes orchestrator + Claude models worn as a name); mapped to hermes-agent/claude-opus-4-8 rather than a new Person node (synthetic byline, not a real person → dedup-halts). Folded the artifact-pole + author-persona note into the loop synthesis thread. Entity discovery: no new nodes (Nous + Hermes paged; no real Person/Org/Event introduced). +1 page.

[2026-06-16] ingest | agentic-tooling (umbrella node) — kind-coverage gap

Added the spoke’s missing domain umbrella agentic-tooling (DefinedTerm, kind:domain) — flagged by the entity-gaps kind-coverage audit (11 kinded concepts, no domain node). Ties the synthesis’s layers together (skills/agentskills-spec · agentic-coding-harness · agent-orchestration/loop-engineering · durable-agents/self-improving-agents · agent-guardrails) under the “structure is the lever” through-line; links synthesis. No new sources (synthesis node). +1 page.

[2026-06-16] ingest | zouroboros (hub-routed, Telegram) — convergence instance + consensus-gate verification

GitHub repo (marlandoj/zouroboros) via Telegram — a self-enhancing multi-agent orchestration platform. Added zouroboros (SoftwareSourceCode, source:true, T1 first-party repo: code + 757 tests + 8 npm packages). Clean single-spoke route: dominant substance is agent orchestration + memory + self-improvement + resilience — a convergence instance like hermes-agent/gstack (it even uses Hermes as one of 5 executors). Gap-relevance: a third design point for the loop/verification thesis — its self-improvement loop gates procedure changes through a 3-model consensus vote (GLM-5.1/Kimi-K2.6/ MiniMax-M2.5), vs autonovel‘s LLM-judge and autoresearch‘s objective metric; folded into the self-improvement synthesis thread (layer 5) as the head-on answer to the drift/quality open risk. Cross-linked into self-improving-agents (instance) + agent-memory (episodic/procedural/cognitive over SQLite+vector). Entity discovery: +1 node zo-computer (Organization, thin/evidence-only — the host platform; no match in entity-index); skipped the bare GitHub handle marlandoj (low-signal pseudonym, recorded inline). Runner-up spoke: llm-providers (the consensus models GLM/Kimi/MiniMax) — noted, not split. +2 pages (agentic-tooling → 68).

[2026-06-17] ingest | Memory Vault — Postgres+pgvector MCP memory for Claude Code

Hub-routed from a Telegram MakeUseOf how-to (“I fixed Claude’s memory problem with a Postgres database…”). Dominant substance is an agent-memory infrastructure product, so a clean single-spoke route here. Added memory-vault (SoftwareApplication, source:true, T3 — a MakeUseOf install-walkthrough, not project docs or an independent test; url-only). It’s the second standalone memory-as-infrastructure instance after seekdb and marks the opposite weight pole: a thin open-source MCP server (stock Postgres + pgvector, hybrid vector+keyword search, docker compose up) whose distinguishing move is delivery over MCP — the store reaches the agent as a tool (the storage-layer reading of “skills × MCP = agency”), vs seekdb being a database the harness queries. Target: externalize the context Claude Code loses to lossy auto-compaction so memory survives /clear / machine switch. Folded into agent-memory (new “lightweight instance” section + two-pole framing) and synthesis layer 6. Gap-relevance: gives the memory-infra layer a second data point and a market-spectrum (heavyweight DB ↔ thin MCP store). Entity discovery: no new nodes — publisher MakeUseOf (generic T3 how-to site) and tool author mihaibuilds (thin GitHub handle) are low-signal, recorded inline (same call as the marlandoj skip). Reused cross-wiki bridges anthropic, model-context-protocol. Runner-up spoke: research-wiki (the persistent-memory / tools-for-thought angle) — noted, not split. +1 page (agentic-tooling → 69).

[2026-06-17] ingest | The Second Son of the House of Bells — re-seen refresh

Same URL (nousresearch.com/bells) arrived again via Telegram. Re-seen source → refreshed second-son-house-of-bells in place (no duplicate, no new page; count stays 69). Verified the live page against the existing summary: all prior claims hold. One concrete addition — the landing page credits the work explicitly as “A work of fiction by Hermes Agent,” which directly backs the hermes-agent-orchestrator side of the “Claude Hermes” persona reading (previously inferred from autonovel). Folded that line into the persona section; bumped updated → 2026-06-17.

[2026-06-18] ingest | Agentic Resource Discovery (ARD) specification (Google)

Telegram-dropped; hub-routed → agentic-tooling (runner-ups: ai-governance for the trust/verification layer, search-marketing for “registries = search engines for the agentic web”). Source summary + standard page agentic-resource-discovery (DefinedTerm, source:true, url, T1 — Google’s first-party announcement). Gap-relevance: adds a fifth edge to the spoke’s standards layer — discovery (how an agent finds + trusts capabilities across orgs) alongside skills/context/tools/interop. ARD is a meta-standard: ai-catalog.json at a well-known path + registries indexing MCP servers / A2A agents / OpenAPI tools, domain-rooted crypto trust; data model under the Linux Foundation AI Catalog WG (same governance arc as a2a-protocol/agents-md). Integrated into synthesis (four→five edges) and cross-linked from a2a-protocol (ARD indexes Agent Cards). Entities: publisher google (bridge node, llm-providers-wiki) linked; authors Junjie Bu / Srinivas Krishnan noted in prose but not noded — consistent with house style for Google-blog ingests (the ADK guides got no author nodes). Cross-spoke facets recorded in the page (ai-governance trust layer; search-marketing agentic-web discovery). Adoption one-vendor-deep (Google Cloud Agent Registry / Gemini Enterprise). freshness: fresh. Rebuild + commit follow.

[2026-06-18] ingest | Anthropic “pauses” token-based billing for the Claude Agent SDK (Ars Technica)

Telegram-dropped; hub-routed → agentic-tooling (runner-up: llm-providers-wiki for the API-pricing angle — noted cross-spoke, not split, since the dominant subject is the Agent SDK product and its harness economics). Ars Technica (Kyle Orland) hard-blocked WebFetch → fetched via the firecrawl skill. New source summary anthropic-agent-sdk-billing-pause (TechArticle, source:true, url, T2 — reputable secondary journalism over first-party support-page text + named primaries). Gap-relevance: opens the spoke’s first explicit treatment of harness cost structure — the unaddressed flip side of the “value-moved-to-the-wrapper / model-vendor-sells-the-wrapper” thesis. Contradiction handled: the prior claude-agent-sdk page asserted “from 2026-06-15 it draws on a separate Agent-SDK credit” — that change was paused June 15/16, so I replaced the stale parenthetical with a dated “Billing: a paused metering change” section (both the announced plan and the pause recorded) and bumped its updated. Folded the cost-structure tension into synthesis (Vendors). Entities: new ars-technica (NewsMediaOrganization, publisher) + boris-cherny (Person, Head of Claude Code — the quoted voice; worksFor anthropic bridge node). Author Kyle Orland (gaming editor, tangential) and third-party consumers Zed/Xcode/JetBrains noted as plain mentions per house style. +3 pages (agentic-tooling → 73). Rebuild + commit follow.

[2026-06-18] ingest | autoresearch (Karpathy) — re-seen refresh

Same URL (github.com/karpathy/autoresearch) arrived again via Telegram. Re-seen source → refreshed autoresearch in place (no duplicate, no new page). Re-fetched repo against the existing summary: all prior claims hold (single-GPU nanochat, edit-train.py-only action surface, fixed 5-min budget, val_bpb keep/discard loop, MIT). Only deltas were noise (stars ~87k→87.5k, community MacOS/Windows/AMD forks); nothing material to add. Bumped updated → 2026-06-18.

[2026-06-18] ingest | autoresearch (Karpathy) — landing page re-seen

The project’s official landing page (autoresearch.lol) arrived via Telegram (hub msg 513) after the repo refresh above. Same project, different URL — recorded the landing-page URL on autoresearch as first-party provenance (it restates the “five-minute loop” pitch + Python 3.10/uv/NVIDIA-GPU reqs, adds nothing beyond the repo). Repo stays canonical; no new page, no duplicate.

[2026-06-18] ingest | DefinedTerm enrichment pass (subagent, completed by orchestrator)

Hub-wide DefinedTerm enrichment (“go deeper, fetch sources”). A subagent deepened the thinnest concept pages with fetched T1 sources but was cut off by a session limit before finishing bookkeeping; the orchestrator completed the index/log. New source pages: building-effective-agents (Anthropic), adk-sessions-docs (Google ADK), agents-md-spec (agents.md), langchain-middleware-docs, self-evolving-agents-survey (arXiv 2508.07407). Deepened concept pages: agentic-tooling, agents-md, durable-agents, loop-engineering, self-improving-agents (sourced facts + Related footers). No fabricated facts; AI-writing gate re-run by orchestrator (clean).

[2026-06-20] ingest | Cult UI — AI agent patterns collection (hub-routed)

Telegram drop (hub msg 532; osp.fyi/cult-ui → opensourceprojects.dev). @nolly-studio’s GitHub collection of 92+ copy-paste AI-agent patterns (ReAct / plan-and-solve / RAG + web-search/code-exec/db building blocks) on the Vercel AI SDK — “recipes, not a new SDK.” New source cult-ui-agent-patterns (SoftwareSourceCode, T3 — secondary roundup of the first-party repo). The recipe-library point on the agent-structure spectrum; a code-level instance of building-effective-agents‘s “simple composable patterns over heavy frameworks” thesis, on the “agent = composition” thread. Cross-linked agentic-coding- harness / orchestration / spec-driven-development.

[2026-06-19] ingest | AutoWiki (Factory.ai) — hub-routed

Telegram drop (hub msg 529, factory.ai/news/wiki). Factory.ai’s multi-agent system that auto-generates + continuously refreshes a code wiki (“documentation as a build artifact”), stored in-repo under droid-wiki/, browsable by Factory’s Droids as shared agent context. Routed here (dominant substance = an agentic coding product) over runner-up research-wiki — though it’s a concrete instance of research-wiki’s llm-wiki concept (a machine maintaining a file-based markdown wiki, like this hub). New source autowiki-factory (TechArticle, T2 — first-party vendor, promotional). Connects the spoke’s “structure/harness” thesis (agentic-coding-harness) and the agent-context thread (agent-memory). T2 vendor-bias recorded.

[2026-06-20] ingest | headroom (context-compression toolkit) — hub-routed

Telegram drop (hub msg 541, github.com/chopratejas/headroom). Local-first toolkit compressing tool outputs/ logs/files/RAG/history before the LLM — 60-95% fewer tokens, claimed answer-parity. Content-typed compressors (SmartCrusher JSON, AST-aware CodeCompressor, Kompress-base HF prose model, CacheAligner for KV-cache hits, CCR reversible). Surfaces: library / proxy / CLI / MCP server; cross-agent shared memory

[2026-06-21] ingest | Ponytail — “lazy senior dev” minimal-code agent skill

Source: DietrichGebert/ponytail (GitHub, MIT, ~45.9k★), via a Telegram-channel GitHub link (hub-routed). An AI agent skill that constrains coding agents to write the minimum code — decision ladder (need it? → stdlib → native feature → existing dep → one line → minimum that works), intensity modes (lite/full/ultra/off), review/audit/harvest/benchmark commands, “never compromise safety/validation/security.”

Added ponytail (SoftwareSourceCode, T1 first-party repo; efficacy numbers flagged self-reported). Folded into synthesis layer 3 as a third counter-current beside the augment pole (lathe, renwei-writing): restraint of the agent rather than keeping the human in the loop — the loadable-skill primitive is now “pole-agnostic three ways” (add capability / augment human / discipline output down). Strong standardization-reach data point: 15+ hosts, still per-host delivery. Self-reported metrics (~54% less code, up to 94%; 20% cost, 27% faster, 100% safety) feed the standing benchmark open question — README claim, not a neutral measurement. Author noted inline (pseudonymous handle, low graph signal — skill-pack precedent). WebFetch on github.com succeeded. Updated index.md (+1 SoftwareSourceCode). +1 page.

[2026-06-21] ingest | Easy Agent — teaching-scaffold coding-agent CLI (rebuild a harness in 31 stages)

Source: ConardLi/easy-agent (GitHub, MIT), via a Dan Kornas tweet (hub-routed from Telegram). A terminal-native agentic coding CLI (TypeScript/Node, React/Ink TUI) that recreates a Claude Code-style workflow with the architecture made explicit: five layers (provider I/O, tools, agent loop, session/orchestration, terminal UI), real tool surface (file/shell/search/web/MCP + permissions

  • sandboxing), multi-provider (Anthropic/OpenAI-compatible/Gemini/Ollama), and 31 standalone step-snapshots for study.

Added easy-agent (SoftwareSourceCode, T1 first-party repo). Folded into synthesis layer 2: it turns the harness decomposition into a curriculum — the agent = model + harness formula made legible (same parts the spoke names, separated on purpose), provider-agnostic like claw-code, and a teaching-pole cousin of lathe aimed at how a coding agent is built. Author noted inline (GitHub handle, low signal). github.com WebFetch blocked earlier this session for x.com only; repo content via firecrawl scrape of the announcing tweet. Updated index.md (+1). +1 page.

[2026-06-23] ingest | Cybersecurity Skills (mukul975) + DeerFlow (ByteDance) — Telegram burst

Two agent-tooling sources from one Telegram burst:

  • cybersecurity-skills (T2) — an 817-skill cybersecurity skillpack on agentskills.io (Mahipal Jangra/@mukul975, Apache-2.0, ~18.7k★). Domain incidental like agentic-seo-skill; what’s new is scale — the largest skillpack the wiki has paged, a working test of progressive disclosure at 817 frontmatters (~30 tokens each). Reflexive twist: 2 of its 6 framework mappings (MITRE ATLAS, NIST AI RMF) cover attacking/defending agents. Flagged the misleading “Anthropic-” name (community, NOT official — contrast anthropic-skills). Paged author mahipal-jangra (Person). Folded into synthesis layer 1 (skills).
  • deer-flow (T2) — ByteDance “SuperAgent” harness (LangChain/LangGraph, MIT, ~73.2k★): sandboxes + persistent agent-memory + markdown skills + parallel sub-agents + a Telegram/Slack/Feishu message gateway; long-horizon (minutes–hours). Paged bytedance (Organization) as the big-tech entrant in the harness-vendor stratum (microsoft/Google adk/langchain/ByteDance all ship the same composition). Folded into synthesis layer 2 (harness). Cross-linked existing langchain org node. Both fetched live via WebFetch. Index updated (SoftwareSourceCode +2, Organization +1, Person +1). +4 pages (agentic-tooling 83→87). Ran avoid-ai-writing criteria over new prose. (No build/commit here — hub handles.)

[2026-06-23] ingest | ADK + A2A cross-language multi-agent team (Google guide)

New source page adk-a2a-cross-language (T1 — Google Developers Blog, Saboo & Dong, 2026-06-22). Turns the A2A “agent↔agent across vendors/frameworks” thesis into a running cross-language example: a Python ADK orchestrator (SequentialAgent) drives a Go compliance validator wrapped as RemoteA2aAgent — the Go service is plain HTTP, no AI framework, A2A-compliant by protocol adherence alone. Exercises all three A2A mechanisms (Agent Card at /.well-known/agent.json, JSON-RPC message/send, Task states) + a resilience pattern (unreachable agent → human MANUAL_REVIEW). Refreshed a2a-protocol (added “Worked instance”) and adk (RemoteA2aAgent/SequentialAgent orchestration; bumped updated). Folded into synthesis’s interop-edge thread (orchestration provably crosses language+framework). Index updated (BlogPosting group). Authors noted inline; publisher cross-linked to google (no new person nodes for blog authors). +1 page (agentic-tooling 87→88). Fetched live. (No build/commit here — hub handles.)

[2026-06-23] ingest | OpenUI (thesysdev) — generative-UI framework

New source page openui (T2; via @tom_doerr on X, resolved through a share.google redirect; X post fetched with the firecrawl skill after WebFetch hit HTTP 402). OpenUI is a full-stack generative-UI framework: LLMs emit a compact streaming DSL (“OpenUI Lang”, benchmarked ~67% fewer tokens than JSON) from a developer-defined component set, rendered progressively by a React runtime. Routed here as the second source in the agent/LLM-rendered-output corner after arrow-js, with the contrast as the synthesis hook: arrow-js = LLM writes real framework code, WASM-sandboxed (bound reach); OpenUI = LLM writes a constrained DSL from an allowed component vocabulary (bound grammar). Both are agent-guardrails containment moves; OpenUI’s token-efficiency rhymes with the token-budget thread (headroom, progressive disclosure). Cross-linked arrow-js (added a counterpoint section). Scope caveat logged: OpenUI is general LLM-to-UI, not agent-specific — routed here for lack of a generative-UI/frontend spoke + the arrow-js precedent; spin-out candidate if the corner grows. Index + synthesis updated. +1 page (agentic-tooling 88→89). (No build/commit here — hub handles.)

[2026-06-23] ingest | Recall — offline durable memory for Claude Code

New source page recall (T2; raiyanyahya/recall, Python, MIT, ~387★). A Claude Code plugin for fully offline session memory: SessionStart/Stop hooks + slash commands, storage as plain markdown files (.recall/history.md append-only + context.md regenerated summary, committable for team memory), summarized by a deterministic vendored TF-IDF/TextRank extractor — no embeddings, no LLM, no DB. Routed as the third, most-minimal pole of agent-memory: the spectrum is now DB (seekdb) → pgvector-over- MCP (memory-vault) → markdown-files-over-hooks (recall), and recall also breaks the MCP delivery shape (hooks, not a tool). Updated agent-memory (new “minimal pole” section; bumped updated) and folded into synthesis’s memory thread. Cross-link: recall’s “committable markdown you own” is the strongest cross-wiki seam yet to research-wiki’s gbrain/llm-wiki markdown-as-system-of-record. Index updated (SoftwareApplication group, beside memory-vault). +1 page (agentic-tooling 89→90). Fetched live. (No build/commit here — hub handles.)

[2026-06-23] ingest | OpenClaw vs Hermes — the control-layer contest (The New Stack)

New source page openclaw-hermes-control-layer (T2 — TNS analytical feature; fetched via firecrawl after WebFetch returned only page chrome). The cleanest comparative frame yet for the harness thread: openclaw and hermes-agent agree on the harness anatomy (runtime + gateway + memory + tools + identity + policy) but differ on the primary control point — OpenClaw gateway-first (breadth: dozens of channels, ClawHub marketplace, ~380k★, Steinberger→OpenAI-sponsored foundation) vs Hermes memory-first (depth: persistent memory + self-refining skills on infra you own; ~160k★, OpenRouter token leader; hermes claw migrate). Created canonical openclaw node (recurred across 3 pages without one) — gateway-first harness, governance added externally by Nvidia NemoClaw (OpenShell sandbox) + Microsoft Scout (Entra identity). Refreshed hermes-agent (memory-first/lock-in framing + metrics) and cross-linked/refined claude-code-channels-vs-openclaw (gateway-first recasts its self-driven framing — flagged as refinement, not contradiction). Folded into synthesis layer 2: memory = the durable lock-in (elevates agent-memory to strategic moat) + vendors claim the agent-agnostic runtime/governance layer (“outlasts any single model”). Security note: 341 malicious ClawHub skills. Index +2 (Article source + openclaw SoftwareApplication). +2 pages (agentic-tooling 90→92). (No build/commit here — hub handles.)

[2026-06-23] ingest | NemoClaw (NVIDIA) — agent-agnostic governance runtime

New source page nemoclaw (T2 — primary NVIDIA repo, Apache-2.0, ~21.4k★, alpha) + new nvidia org node. The first-party primary source for the vendor runtime-governance thesis just synthesized from openclaw-hermes-control-layer — and broader than that article implied: NemoClaw runs openclaw, hermes-agent, AND LangChain Deep Agents under one CLI inside OpenShell sandboxes. Governance around the agent: per-instance sandbox, capability dropping, egress/network policy + operator approval, lifecycle, and the distinctive managed/“routed” inference (the agent can’t call model endpoints directly — governance owns which model it may call, not just which files). Folded into synthesis (the vendor-runtime-layer paragraph now cites the primary source + the 3-harness agent-agnostic detail + managed inference); linked nemoclaw from openclaw. agent-guardrails as external containment; the NVIDIA counterpart to Microsoft Scout (multi-harness/OpenShell vs single-harness/Entra). Index +2 (nemoclaw source + nvidia org). +2 pages (agentic-tooling 92→94). Fetched live. (No build/commit here — hub handles.)

[2026-06-24] ingest | Hermes /learn — skill capture without hand-writing SKILL.md (MarkTechPost)

New source page hermes-learn-skill-capture (T3 — MarkTechPost relay of a Nous Research feature). Hermes’s new /learn command auto-authors a standards-compliant SKILL.md from a doc/URL/SDK/past conversation, reusing the agent’s own tools (read_file/search_files/web_extract); skills land in ~/.hermes/skills/, become slash commands, use 3-tier progressive disclosure (L0 index ~3k tokens → L1 skill → L2 refs). Key analytical contribution = a skill-authoring autonomy spectrum: hand-write → /learn (assisted) → skill_manage auto-capture after 5+ tool-call workflows (unprompted) → Hub install (community), with an (off-by-default) write_approval review gate. Folded into self-improving-agents (the spectrum + approval-gate-as-drift- control, sibling of zouroboros‘s consensus vote) and hermes-agent (skill-authoring side); synthesis layer-5 note: the standard decouples who authors from the format as the author slides human→agent. Index updated (TechArticle group). +1 page (agentic-tooling 94→95). Fetched live. (No build/commit — hub.)

[2026-06-28] ingest | Google Antigravity 2.0

New page google-antigravity (SoftwareApplication, source, T3, geeky-gadgets.com), routed from the hub. Google’s developer-facing agent IDE (“agent operating system”) — the front-end twin to SDK-side adk. The 2.0 update split the unified app into two (VS Code-style IDE + separate chat-agent app), a bet on IDE-surface vs chat-surface as distinct control points; reception mixed (usability regression + tighter usage limits). Carries the standard harness anatomy: dynamic sub-agents, async/scheduled background ops in remote Linux, /goal & /browser slash commands + Chrome-DevTools browser control, an Antigravity SDK + CLI, JSON hooks, multi-folder scoped permissions. Folded into synthesis’ harness-vendor stratum thread (Google now ships both kit and IDE; the split-app bet mirrors openclaw-hermes-control-layer within one vendor; the cost/UX friction is the consumer twin of anthropic-agent-sdk-billing-pause). Source weakness recorded: secondary tech-blog coverage of a product update, no primary docs — feature specifics reported, not confirmed; a primary antigravity.google source would upgrade this. No new entity nodes (owner google is an existing cross-wiki bridge node; geeky-gadgets too thin to page).

[2026-06-29] ingest | Tail Control — reliable agentic workflows (TDS) — hub-routed

Adds the reliability/latency dimension the spoke lacked (most of the corpus = building/orchestrating; this = hitting a deadline). New source tail-control-agentic-workflows (TechArticle, T3, towardsdatascience.com — Frank Wittkampf/Databook; 1.2M+ enterprise calls). Thesis: predictable completion beats fast-with-a-tail. Latency heavy tails (p99 30–80s vs ~12s median, 2–7× within identical requests) compound across steps (10×95%≈60%, 20≈36%); fixes = SRE tail-control applied to agents: cut at p95, race redundant attempts (first valid; p99 ~60→25s), hedge to another provider’s quota, downshift on transient stalls. Folded into building-effective-agents (the workflow/agent split gains a reliability rationale — workflows are the tail-tractable form), agent-orchestration (parallelism for redundancy vs decomposition), and synthesis (reliability’s second axis = latency, not just safety). Dedup: no existing reliability/tail node — net-new theme. Cross-spoke platform-ops-wiki (SRE tail-at-scale / hedged-requests heritage) noted, not forked. T3 weakness recorded (single-source practitioner data). Runner-up spoke: platform-ops.

[2026-06-29] ingest | Claude Fable system prompt “leak” (Medium) — hub-routed

New source claude-fable-system-prompt-leak (TechArticle, T4 — unverified leak, medium.com / Mehul Gupta). A claimed leaked Claude Fable system prompt; routed here because its content + own thesis is the spoke’s “everything wrapped around the model”: one configured layer of tools (web search, artifacts, MCP connectors, code execution), memory, safety (child-safety/malware/weapon refusals), and behavior (warm tone, anti-over-formatting — the same anti-slop rule the hub uses). Folded a single caveated line into the synthesis thesis intro (illustrates, doesn’t prove). Authenticity heavily caveated: no provenance, low- tier blog, ~190K-token claim suspect — read as illustrative, not a primary source on Claude’s real config; no durable Thing pages built on it. Cross-spoke: research-wiki owns the model substrate (Claude Fable 5) = runner-up; ai-governance adjacency (safety rules are product instructions, not policy) noted, not forked. Runner-up spoke: research-wiki.

[2026-06-30] ingest | Superpowers (obra) — agent-skills framework + dev methodology

Routed from a Telegram review article (member-only Level Up Coding / Medium, “I Installed ‘Superpowers’ Into Claude Code”, Abhishek Agarwal — T4). Dedup: no existing page/mention. Grounded in the T1 repo superpowers (github.com/obra/superpowers, MIT) rather than the paywalled blog. New page superpowers (SoftwareSourceCode, T1) — Jesse Vincent (obra) + Prime Radiant team’s composable agent-skills framework: ~two dozen skills the agent self-invokes (brainstorming, writing/executing-plans, TDD, verification-before-completion, systematic-debugging, requesting/receiving-code-review, git-worktrees, dispatching-parallel-agents, subagent-driven-development, writing-skills, using-superpowers). Cross-harness (Claude Code/Cursor/Codex/Copilot/Gemini CLI). Flagged volatile claim: ≈242k★ (GitHub snapshot) — high enough to re-verify; the review raised the same caution. Entity jesse-vincent (Person, obra) created; Prime Radiant kept as prose mention (thin). Folded into synthesis layer 1 (capability-as-markdown) as a methodology-as-skills instance spanning into orchestration; index updated (SoftwareSourceCode + Person). Reflexive note recorded (the skill system this hub session runs on). Ran avoid-ai-writing.

[2026-06-30] ingest | From local LLM to tool-using agent (TDS)

Routed from Telegram. New source from-local-llm-to-agent (TechArticle, T4, towardsdatascience.com) — a practitioner walkthrough building a fully-local “mini deep research agent”: Gemma 4 E4B on Ollama (OpenAI-compatible endpoint) driven by the OpenAI Agents SDK calling MCP tools (Tavily search), running the canonical agent loop (query→tool calls→MCP exec→cited answer). Dedup: no existing page. Integrated into synthesis layer 1 as a concrete, fully-local worked example of the “skills × MCP = agency” formula — agency decoupled from the model substrate (no cloud model needed). Cross-spoke context noted in-page (Ollama→llm-inference, Gemma→llm-providers) rather than fragmenting; dominant substance = agent-building pattern, so routed here. Author/Tavily/OpenAI entities deferred (T4 tutorial; tangential). Ran avoid-ai-writing. +1 page (→101).

[2026-06-30] ingest | Knowledge RAG — local-first RAG MCP server for Claude Code

Routed from Telegram. New source knowledge-rag (SoftwareSourceCode, T1 [spoke repo convention], github.com/lyonzin; MIT, ~135★, v4.3.1). A local-first RAG server exposed to Claude Code as 13 MCP tools: hybrid retrieval (bge-small-en-v1.5 semantic + BM25 inverted index)

  • cross-encoder rerank (ms-marco-MiniLM), ChromaDB, ONNX Runtime (CPU/CUDA), 20 format parsers, stdio/SSE/ HTTP, zero external APIs. Its primary identity is an MCP server / agent tool (per its own README), not a novel retrieval technique → here, not research-wiki; the retrieval science (hybrid semantic+BM25+rerank) cross-links research’s hybrid-retrieval-rag. Folded into synthesis’s local-first/MCP-store axis (seekdb→ memory-vault→recall) as the document-retrieval sibling (retrieval-rich end vs recall’s zero-dependency end); paired with headroom/from-local-llm-to-agent. Author (Lyon/lyonzin) entity deferred (one-off, tangential). Ran avoid-ai-writing. +1 page (→102).

[2026-06-30] ingest | autoharness — self-maintaining skill layer for Claude Code

Routed from Telegram (hub router). New source autoharness (SoftwareSourceCode, T3 — project README, self-reported; tigerless-labs). A Claude Code plugin that manages the whole self-authored skill library from real usage: distils sessions (user input / agent output / tool interactions) into skills, consolidates similar scenarios instead of accumulating near-duplicates, folds new evidence into existing skills, and archives by invocation rate; daemon-free, no held-out benchmark, append-only ledger kept out of skill bodies, Python 3.11+ zero-dep, MCP-wired. Dedup: no existing page — closest neighbours are hermes-learn-skill-capture (authors one skill) and self-improving-agents (the mechanism), so paged as the library-level instance. Folded into synthesis layer 5 as a fourth drift-control design point (real invocation/adherence signal + author-only scoping + pre-deploy validation, vs zouroboros’s vote / autonovel’s LLM-judge / autoresearch’s metric). Its unverified 42%→78% README claim flagged against the Open-questions/Benchmarks gap (and against its own benchmark-free design). Owner org tigerless-labs paged as a thin evidence-only node. Ran avoid-ai-writing. +2 pages (→104).

[2026-07-01] ingest | ADK Go 2.0 (Google) — graph-based workflow engine

T3 vendor blog (developers.googleblog.com). Dedup: adk already paged → enriched in place (new “ADK Go 2.0” section) + new source adk-go-2 and a new concept page graph-based-agent-workflow. The 2.0 release (v2.0.0, 30 Jun 2026) rebuilds ADK around a graph of typed nodes + conditional edges run by a scheduler — “a graph is an agent” (same runtime for single

  • multi-agent). Nodes: function/emitting/agent/tool/join/dynamic/workflow/parallel/state-bound; routing via StringRoute/IntRoute/BoolRoute/MultiRoute/Default (an LLM can emit the route). Reliability in the runtime: per-node retry (5 attempts, 1s→60s, 2×, jitter), timeouts, WithMaxConcurrency, branch isolation. First-class durable HITL — any node pauses into session state, resumes by handoff/re-entry across process restarts (reconstructs from session history). Unified runtime + Chat/Task/SingleTurn modes; ToolContext+CallbackContext → one agent.Context. Resume format shared with Python ADK 2.0 (cross-runtime resume); plugs into A2A. Touched adk, agent-orchestration (added the declarative-graph counterpart to imperative fan-out), durable-agents (durable pause/resume promoted to base runtime), synthesis (layer 4 durability — “a graph is an agent” as the sharpest structure-over-capability instance). Breaking-change notes captured. Volatile snapshot.

[2026-07-01] ingest | WhatsApp ChatGPT Bot (Wassenger)

Telegram source (github.com/wassengerhq/whatsapp-chatgpt-bot), hub-routed here. MIT Node.js bot that turns a WhatsApp number into a multimodal GPT-4o assistant via the Wassenger WhatsApp API: webhook in → model → reply out, per-conversation memory, persona set by a config.js system prompt. Features: multimodal I/O (text/image/audio in, synthesized speech out), RAG via tool/function-calling (functions.js), MCP support, token/rate/size limits + number blacklist/whitelist, and human handoff. New pages: whatsapp-chatgpt-bot (source summary, SoftwareSourceCode, url-only) + wassenger (Organization, thin node, channel/gateway-vendor stratum). Folded into synthesis as the channel-gateway corner open question — the terminal-coding harness anatomy pointed at a consumer messaging channel — and as a data point that MCP is spreading past the Claude ecosystem (an OpenAI-based, non-coding bot shipping MCP). Cross-linked knowledge-rag, cult-ui-agent-patterns (RAG/tool-use), deer-flow + openclaw (message-gateway echo), agent-guardrails (human handoff). Tier T3 — first-party primary artifact but a vendor-promotional demo selling the Wassenger API; modest traction (167★). Entity discovery: Wassenger paged; MCP is an existing cross-wiki bridge node. No contradictions. Per 2026-07-01 policy: no per-route rebuild/verify.

[2026-07-01] ingest | Build agentic full-stack apps with Genkit (Google)

Telegram source (developers.googleblog.com/build-agentic-full-stack-apps-with-genkit), hub-routed here. Google’s open-source agent-building framework for full-stack AI apps — packages message history, tool loops, streaming, and persistence behind one interface. New page genkit (SoftwareApplication, source, T1 first-party). Key surface: Agents API (server-side agents; same chat() local or remote), pluggable session stores (in-memory/file/Firestore/custom — a first-class agent-memory/durable-agents layer), HTTP-servable agents (snapshot/abort), a JS/TS remote agent client with an identical API (unified full-stack code), interruption for HITL + delegation middleware for orchestration (cf. agent-middleware), and an Agent Runner dev UI; TS/Go/Dart/ Python. The post explicitly contrasts it with adk (managed runtime for complex topologies) — Genkit is the embeddable library pole, so google now fields two agent frameworks at different altitudes. Folded into synthesis Vendors as further Google convergence evidence. Cross-linked google (cross-wiki org). Tier T1. No new contradictions. Per 2026-07-01 policy: no per-route rebuild/verify.

[2026-07-02] ingest | awesome-agent-evolution (EvoMap) — the field-map as an outside taxonomy

Routed from Telegram via the hub router. New source awesome-agent-evolution (Collection, T3, github.com/EvoMap; url-only) — EvoMap’s 150+-entry curated “awesome list” of the agent-self-evolution field, with twelve sections (self-improvement, memory, agent-to-agent protocols, dev platforms, coding agents, prompt/behaviour optimization, safety/guardrails, embodied AI, research papers, benchmarks, taxonomy, community). Value is meta: an unaffiliated curator carves the field into nearly the same layers this spoke reached bottom-up (self-improving-agents, agent-memory, a2a-protocol, agentic-coding-harness, agent-guardrails, self-evolving-agents-survey) — mild external corroboration of the layer model. Folded a “an outside curator now draws the same map” note into synthesis layer 5, and added a lead-not-answer pointer to the Benchmarks open question (a directory of benchmarks ≠ a benchmark). Flagged the spoke’s one blind spot the list exposes: Embodied AI. Did not page the 150+ entries — the catalog is the subject; named Mem0 (~60k★, an agent-memory product), Eliza, Agent Zero as page candidates only (a star count + one-liner isn’t grounding). Added thin Org node evomap (curator/owner; evidence = repo + evomap.ai). Ran avoid-ai-writing. +2 pages (source + evomap).

[2026-07-04] ingest | Claude apps gateway for Google Cloud — the harness-vendor’s own runtime-governance layer

Msg 724 (cloud.google.com/blog/…/announcing-claude-apps-gateway-for-google-cloud, via Telegram). T3 (first-party vendor announcement; technically substantive — architecture/gateway.yaml/deploy steps — and points to T1 docs at code.claude.com, but the ingested source is the blog). New page claude-apps-gateway (TechArticle, url). Self-hosted stateless proxy (Cloud Run + Cloud SQL + Secret Manager) between Claude Code clients and Vertex AI, co-authored Anthropic (Roy Arsan) + Google Cloud (Ivan Nardini). Centralizes five fleet controls: IdP identity (device-code → OIDC, short-lived tokens, no laptop keys), RBAC policy (gateway.yaml, server-side per /v1/messages), spend caps (Cloud SQL ledger, HTTP 429 over cap), telemetry/attribution (verified-JWT → OTLP → Cloud Monitoring/Grafana/Datadog), routing/failover (single service identity, inference stays in-VPC). Folded into synthesis as the third shape of the vendor runtime-governance layer — the first-party/single-harness counter-instance to third-party nemoclaw/microsoft-scout (Anthropic governing its own Claude Code, same control-plane-owns-which-model-you-call move). Two loops closed: operational answer to the SDK cost-structure tension (cap+attribute vs reprice), and the governance twin of agent-starter-pack (Cloud-Run deploy vs govern-fleet). Cross-spoke: platform-ops (observable Cloud Run service) + llm-providers/cloud (Vertex/GCP). Did not page the two blog co-authors (thin, single-connection). +1 page. Ran avoid-ai-writing. Per-route verify deferred (routine ingest, no structural page move).

[2026-07-04] ingest | Tokenmining — the named cost/token discipline (routing + compaction)

Msg 731 (towardsdatascience.com/tokenminning…, via Telegram). T3 (TDS practitioner how-to; anecdotal cost figures — $40/day, “$10k+/week” — not a controlled study). New page tokenmining (TechArticle, url). “Tokenmining” = the deliberate inverse of tokenmaxxing: minimize tokens while holding/raising quality. Two levers: routing (LLM gateway classifies prompt complexity → cheaper/local quantized model; ~60% cost cut) and context compaction (lossy summarization at the token limit, structured-memory extraction). Thesis: more tokens ≠ better — context rot + lost-in-the-middle mean extra context degrades output, so discipline is a quality argument not just cost. Crystallizes the spoke’s scattered token-budget/cost thread (headroom pre-model compression, tail-control-agentic-workflows model-downshift, claw-code provider-agnostic routing, claude-apps-gateway spend-capped routing, memory-vault compaction-loss) into one named discipline; the cost/quality face of “structure substitutes for capability” (agentsys). Folded into synthesis. Cross-spoke: llm-inference (context-rot mechanism) + research-wiki long-context-vs-chunking (the retrieval-side twin of the same “long context isn’t free/better” thesis — routed there earlier today). +1 page. Ran avoid-ai-writing. Per-route verify deferred (routine ingest, no structural page move).

[2026-07-09] ingest | Conductor CDD launch (Google blog) + repo re-seen → context-driven-development node

Two related sources arrived together (hub-routed): Google Developers Blog “Introducing context-driven development for Gemini CLI” (new) + the github.com/gemini-cli-extensions/conductor repo (re-seen — already the url: of conductor). Dedup: the repo refreshed conductor in place (added the spec + plan.md Phases→Tasks→Sub-tasks artifacts, file-persisted pause/resume state, brownfield support, install command; updated 2026-07-09), not a new page. The blog got the higher-value move: promoted context-driven-development to its own DefinedTerm node (T1, source=Google blog) — CDD as a named third point past vibe coding and spec-driven-development: whole project context (product/stack/workflow) kept as durable reviewed Markdown, not just a per-change spec. Cross-linked spec-driven-development (now points at the dedicated CDD node) and folded into synthesis §3 (the authoring-discipline “named far end”; Google naming it on the Gemini side = harness race converging on planning/context governance). Authors Keith Ballinger / Jay Kornder / Sherzat Aitbayev noted in prose; entity nodes deferred. Ran avoid-ai-writing. +1 page (Conductor refreshed, CDD added).

[2026-07-09] ingest | designpowers — 10-agent inclusive-design team

Routed from hub (Telegram). New source designpowers (SoftwareSourceCode, T3, github.com/Owl-Listener, MC Dean, MIT, ~220★) — a model-agnostic multi-agent design team: 10 role-specialist agents (design- strategist, design-scout, inspiration-scout, design-lead, motion-designer, content-writer, design-builder, accessibility-reviewer, design-critic, heuristic-evaluator) running a Discover→Research→…→Ship→Retrospective pipeline off 36 skills; cross-harness (Claude Code plugin + Gemini CLI extension + Cursor/Windsurf/ Copilot/Aider via shared markdown). Human-as-director: Direct mode (approve every handoff) vs Auto (runs unsupervised, pauses only on accessibility/critic/reviewer-conflict); Design-Taste + optional design- memory. Integrated as an instance, no new mechanism node: cross-linked agent-orchestration (role-split), agent-skills/agentskills-spec (cross-harness portable skills), gstack (role-agent factory, non-design), agent-guardrails (human-checkpoint/Auto-mode). Synthesis §1 vertical-generalization thread extended (role-split team pointed at design; accessibility-as-default vs final-audit). T3 (single self- described repo, modest adoption; efficacy claims unverified). Author (MC Dean) entity deferred. Ran avoid-ai-writing. +1 page.

[2026-07-09] ingest | pm-skills-arsenal (12 deep PM skills, typed schemas) (hub-routed, Telegram)

Ingested Avyayalaya/pm-skills-arsenal (Parth Sangani, MIT): 12 “codex-grade” product-management agent-skills at ~1,000–1,300 lines each, distributed via APM multi-harness manifest, plugin marketplaces (Claude Code / Agency-Copilot / awesome-copilot), an MCP server (5 tools incl. run_skill), and direct SKILL.md. Distinctive move: each SKILL.md declares typed capability_summary/input_schema/output_schema so an orchestrator routes between skills structurally without reading the body — composability-by-schema. New pm-skills-arsenal (SoftwareSourceCode, T2)

  • author parth-sangani (Person). Positioned as the few-deep-routed-by-schema counterpoint to the existing pm-skills (68-shallow-chained-by-commands); cross-linked both ways. Synthesis §1 vertical- generalization thread extended with the typed-function / run_skill-over-MCP angle. T2 — primary source for structure/schemas/distribution, but “codex-grade” + get_benchmark are unverified self-claims (Open-questions benchmark gap). Ran avoid-ai-writing. +2 pages.

[2026-07-09] ingest | Cloud Run sandboxes (Google Cloud, agent-code isolation) (hub-routed, Telegram)

Ingested Google Cloud’s Cloud Run sandboxes (public preview, Next ‘26): a managed primitive to execute untrusted / AI-agent-generated code in an isolated sandbox that runs in-instance (2nd-gen exec env, shares the host container’s CPU/mem, latency-optimized), enabled via gcloud beta run deploy --sandbox-launcher / sandboxLauncher: true; launcher binary at /usr/local/gcp/bin/sandbox, with an ephemeral built-in sandbox tool “coming soon”. New cloud-run-sandboxes (SoftwareApplication, source, T2, volatile). Wired into the containment/governance-as-agent-agnostic-infrastructure thread: alongside nemoclaw/microsoft-scout (control-plane wrapping) and claude-apps-gateway/agent-starter-pack (Cloud-Run deploy→govern), this is the missing execution-isolation rung — containment as a substrate feature beneath the harness, and the server-side sibling of arrow-js‘s WASM sandbox. Synthesis §2 governance-layer thread extended (two altitudes: control plane vs substrate). T2 — first-party vendor docs, authoritative for mechanics but the isolation mechanism (gVisor/microVM?) is unstated and “fast/secure” is unevaluated. Cross-spoke: cloud-wiki (runner-up: Cloud Run as serverless offering / pricing angle), platform-ops-wiki (verification-runtime seam via agent-loops-verification). Ran avoid-ai-writing. +1 page.

[2026-07-12] ingest | Safe prompt pruning for long-context LLM systems (TDS, hub-routed, Telegram)

Ingested Emmimal P Alexander’s TDS build-log on a deterministic prompt-pruning layer: a 3-pass pipeline (expired-tool-output elimination → duplicate-RAG-doc elimination → DEFINE/REF dependency restoration) that removes provably redundant context before the model, no LLM/embeddings — stdlib only, idempotent. Synthetic self-benchmarks: 27–34% token cuts on RAG/tool workloads, ~2–4% on plain chat, 100% required-fact retention, <50 ms at 131k tokens. Honest caveat: the safety pass initially never fired (benchmark never made pruning + dependencies collide). New pages: source summary safe-prompt-pruning (TechArticle, T3); author Person emmimal-p-alexander (thin). Synthesis: extended the token-budget corner from three levers to four — route / compress (headroom) / modality-arbitrage (pxpipe) / prune (this) — the lossless deterministic cousin of tokenmining‘s lossy context-compaction; caveat ties to the verification-bottleneck thread. +2 pages, 3 spine files updated. T3 (single-author synthetic benchmarks, unvalidated).

[2026-07-12] ingest | AI Race Coach built with Antigravity and Gemini (Google Devs Blog, hub-routed, Telegram)

Ingested a Google Developers Blog case study: GDEs built a real-time AI driving coach at Sonoma Raceway (23 May 2026) on Antigravity + ADK. Two synthesis payloads. (1) Antigravity gets a second face — not the coding IDE the spoke paged 2026-06-28 but a runtime “domain-bridging engine” doing stateful telemetry orchestration, with ADK orchestrating the coaching agents in the field (big-tech harness shipping into a live system, not a docs demo). (2) Edge/cloud model split — Gemma 4 local for zero-latency audio alerts, Gemini API cloud for post-session modelling: the spoke’s route-by-latency-and-depth idea (tokenmining, tail-control-agentic-workflows downshift) where latency isn’t a metaphor. Also the corpus’s closest brush with the embodied/physical-agent blind spot EvoMap flags. New page: source summary ai-race-coach (BlogPosting, T3 — vendor case study, specifics reported not verified). Updated google-antigravity (+orchestration-engine facet), adk (+in-production section), synthesis (Google/Antigravity passage in layer 2), index. Ran avoid-ai-writing. +1 page. Entities: publisher google already canonical (bridge node); no new nodes (GDE team anonymous, Brian Luc a thin community mention).

[2026-07-14] ingest | Cognition trusts Claude Fable 5 to work through the night (Anthropic case study, hub-routed, Telegram)

Ingested Anthropic’s customer case study on Cognition (Devin, autonomous AI software engineer) routing long-running work to Fable 5. Substance: Devin runs 8h+ unattended (“through the night”) where earlier models drifted “after minutes to an hour”; the unlock is credited to the model’s horizon (self-sufficiency), a rare once-a-year step-change per SVP Research Silas Alberti. Evaluation practice: “trust no eval” — senior engineers judge whether output would ship — + a proprietary “Frontier Code” anti-slop benchmark (Fable5 ~30% vs Opus ~10%, dogfooding agreeing). Verification discipline: agent states invariants → executes against them → root-causes in triage rather than guessing. New pages: source cognition-fable5-through-the-night (BlogPosting, T3 — first-party promotional, proprietary benchmark); devin (SoftwareApplication); cognition (Organization); silas-alberti (Person, thin). Synthesis: Benchmarks open question gets its sharpest partial step (names the anti-benchmark failure mode + a methodology, but proprietary/vendor + measures the model not the harness); structure-vs-capability question gets a clear counter-current (raw model horizon, not a cleverer harness, was the autonomy unlock — bounds the thesis; ties to effort-level). Cross-links to bridge nodes claude-fable-5/anthropic (llm-providers-wiki was runner-up). avoid-ai-writing applied. +4 pages, 2 spine files updated.

[2026-07-14] ingest | Context rot in Claude Code — Governed Context (TDS) + CCA-F lost-in-the-middle (Medium), paired (hub-routed, Telegram)

Ingested two same-theme practitioner pieces on context management in Claude Code, arriving together. (1) governed-context-claude-code (Jake Minns/TDS, T3): the fullest context-governance playbook — intrinsic (attention/U-curve/lost-in-the-middle) vs content rot (Drew Breunig’s confusion/clash/ distraction/poisoning); 3-phase governance (curate CLAUDE.md/skills/hooks → session hygiene/subagent-offload/ externalize-state → reset over recover); “session as a git tree” (--fork-session, /conclude, /merge). (2) cca-f-lost-in-the-middle (Rick Hightower/Medium CCA-F series, T3): the API-level version — pinned facts + rolling history + reconstruct-every-turn because the Messages API is stateless; context mgmt is a design problem, not a config knob. New concept node context-rot (promotes a phrase that lived inside tokenmining to a first-class mechanism; splits intrinsic/content). New thin Person nodes jake-minns, rick-hightower (spoke convention: cf. emmimal-p-alexander). Synthesis: extended the token-budget corner — context-rot is the why, reframing route/compress/modality-swap/prune from cost to quality (signal-to-noise); “model rarely signals the rot” ties to verification-is-the-bottleneck; governance operationalizes externalize-state/subagent-offload; the stateless-API point is the substrate reason the whole corner exists. Cross-spoke seams: llm-inference-wiki (attention mechanism), research-wiki long-context-vs-chunking (retrieval-side twin). avoid-ai-writing self-pass (clean). +5 pages, 2 spine files updated.

[2026-07-14] ingest | beautify-github-readme — README-redesign agent skill (hub-routed, Telegram)

Ingested beautify-github-readme (oil-oil, MIT GitHub repo): a agent skill (not a library) that redesigns a repo’s README — two modes (Whole-README = restructure hierarchy, proof-before- technical, + full visual system; SVG-only = decorative assets, no copy edits) on a Markdown-for-searchable- text / SVG-for-visual-identity separation; Python, emits GitHub-safe SVG/PNG/WebP + Markdown, project-native (not template) visuals. New pages: source summary beautify-github-readme (SoftwareSourceCode, T2 — primary repo, self-described/unbenchmarked); thin author oil-oil (Person). Synthesis: extended the skills- generalize-to-verticals thread (layer 2) — the vertical list now reaches developer communication / repo presentation, a sibling of designpowers/renwei-writing/ai-job-search/pm-skills and a human-facing counterpoint to the openwiki/autowiki-factory docs-as-artifact thread. avoid-ai-writing self-pass (clean). +2 pages, 2 spine files updated.

[2026-07-14] ingest | Building AI Agents? Here Are Some Anti-Patterns to Avoid (Machine Learning Mastery, hub-routed, Telegram)

Ingested Bala Priya C’s nine-item agent-building anti-patterns checklist (multi-agent-too-soon, one-agent- does-everything/15+ tools, tool-list sprawl, hardcoded monolithic logic, skipping memory architecture, shipping without observability, ungoverned write access, context drift, deploying without evaluation). Its value is corroboration density: the nine map ~1:1 onto the spoke’s synthesis threads — start-simple (building-effective-agents), context bloat/drift (context-rot), layered agent-memory, modular composition (agent-middleware), ungoverned writes (agent-guardrails/agents-never-do-alone), eval (loop-engineering), observability (seam to platform-ops). New pages: source agent-anti-patterns (BlogPosting, T3 — educational roundup, no original data); thin author bala-priya-c. No new concept node (consolidating source, not a new idea). Synthesis: added at the guardrails anchor as a second outside-in corroboration of the layer model after EvoMap (EvoMap maps the field, this enumerates failure modes); flagged its internal tension (recommends layered memory+observability+eval as near-defaults vs its own “don’t over-engineer” lead item — the start-simple↔build-scaffolding balance). avoid-ai-writing self-pass (clean). +2 pages, 2 spine files updated.

[2026-07-14] ingest | How to Orchestrate 100+ Agents With Claude Code (TDS, hub-routed, Telegram)

Ingested Eivind Kjosbakken’s TDS practitioner piece on running 100+ Claude Code agents in parallel via headless mode (claude -p): hierarchical (one orchestrator spawns children), stateless one-shot sessions rather than nested subagent loops, no centralized state (high-level prompting + task isolation to prevent interference), self-verification baked into the task prompt, full per-agent autonomy (MCP + all tools, no per-step approval), scoped to well-defined/reversible work (refactoring; Fable-detects → orchestrator-tasks → Opus-headless-executes → aggregate). New pages: source orchestrate-100-agents-claude-code (BlogPosting, T3 — no throughput/cost/concurrency data); thin author eivind-kjosbakken. Updated agent-orchestration: added as the largest-scale instance + a distinct headless/process-level/isolation flavor (vs nested loops orchestration-mode/agentsys or durable queue gbrain). Synthesis (layer 3): folded in — isolation is where orchestration meets context-rot (fresh-session-per-task = rot-avoidance-by-isolation, the fork/isolate move at fleet scale) and agent-guardrails (safety via task choice, not human checkpoints); honest limit = well-scoped work only (match-pattern-to-task). No new concept node (headless mode folded into orchestration). avoid-ai-writing self-pass (clean). +2 pages, 2 spine files updated.

[2026-07-15] ingest | grok-build — xAI’s terminal coding agent (GitHub, hub-routed, Telegram)

Ingested xAI‘s grok-build (xai-org/grok-build), the open-source Rust terminal coding agent grok: full-screen mouse-interactive TUI that understands the codebase, edits files, runs shell, web-searches, and manages long-running tasks; three modes (interactive TUI / headless CI-scripting / editor-embed via Agent Client Protocol); MCP + plugin extensible; cross-platform; synced from xAI’s internal monorepo. Modular Rust crates (xai-grok-pager TUI · xai-grok-shell runtime · xai-grok-tools file/exec/search · xai-grok-workspace fs/VCS/exec). New page: source grok-build (SoftwareSourceCode, T1 — primary vendor repo/README). Reused existing cross-wiki Org node xai-grok (llm-providers-wiki) as creator — no duplicate xAI node created; added it to the index bridge-nodes list. Placed as the agentic-coding-harness pattern shipped first-party by a model lab (peer to Claude Code / Gemini CLI), on the Rust/systems-language end beside claw-code/oh-my-pi/easy-agent. Synthesis: added a “first-party lab harnesses” thread — labs now compete on the harness, not only the model, yet converge on shared protocols (ACP agent↔editor, MCP agent↔tool); the structure-over-capability split drawn by one company on both sides (model in llm-providers, harness here). Entity discovery: creator xai-grok already canonical (reused); no new entities paged. avoid-ai-writing self-pass (clean). +1 page, 3 spine files updated.

[2026-07-22] ingest | Auto-Company + cc-thinking-skills (GitHub ×2, hub-routed, Telegram)

Two repos arrived together and turned out to argue with each other, so they were ingested as a pair.

auto-company (MaxMiksa, MIT, ~2.0k★, T2): a launchd/systemd daemon that re-invokes Claude Code or Codex CLI every 30s against a company charter, forming 2–5-person squads from 14 expert-persona agent definitions. Read as Ralph with the stop condition removed — with no completion promise and no external feedback signal, the author hardcodes phase transitions in PROMPT.md (ideate → GO/NO-GO → build; “pure discussion is forbidden”) to stop the loop talking to itself. Three existing nodes updated with it: agent-memory gained a minimal pole (consensus.md, one rewritten markdown file as the entire cross-cycle state, explicitly chosen over vector DBs — steerable by editing one line, but historyless); agent-guardrails gained a counterexample (limits stated as prose in CLAUDE.md while the sandbox is bypassPermissions/danger-full-access on the host — enforcement removed, instruction retained); agent-orchestration gained a fan-out variant where the state file picks the roster, not the orchestrator.

cc-thinking-skills (TJ Boudreaux, MIT, ~822★, T2): 39 mental-model skills (Munger/Meadows/Kahneman/Goldratt/Boyd) behind a thinking-model-router meta-skill — and the Elevate-or-Kill eval harness shipped alongside them, length-controlled against a same-length placebo and replication-gated. Result published against interest: zero skills hold a robust replicated ELEVATE verdict; best candidate thinking-scientific-method at +5.3pp / p=0.061 / n=150 → DIRECTIONAL-NOT-REPLICATED. First source in the spoke that measured whether a skill pack works.

New concept node reasoning-scaffolds holds what the pair share: capability skills (grant something the agent lacked) vs cognitive skills (prescribe how it thinks). Auto-Company encodes the second as personas and asserts it; cc-thinking-skills encodes it as skills and finds no measurable accuracy gain — same bet, two indexes, one of them now tested.

Synthesis: layer 1 split into capability-vs-cognitive with the null result recorded; the Benchmarks open question gained its first measurement of the tooling layer (and the length-matched-placebo design worth copying); “does structure substitute for capability” bounded from the thin end — structure appears to pay where it changes what the agent does, not what it’s told to think. Two tensions added: constitution vs containment (prose limits vs an uncrossable boundary, no incident data either way) and memory’s unpriced range (one markdown file vs seekdb‘s forkable store, three orders of magnitude apart, never compared). Entity discovery: 2 new Person nodes (zheyuan-kong, tj-boudreaux); CMU affiliation evidenced but left as a plain mention (relevance gate). avoid-ai-writing self-pass. +5 pages, 4 pages updated, 3 spine files.

[2026-07-22] ingest | Harness AI Agent DLC (The New Stack)

Routed from the hub (route in ../log.md). URL-only, T3 — trade press, but every claim comes from one vendor launch and one vendor executive, with the supporting survey also first-party (Harness’s own State of Engineering Excellence 2026). Fetch note: WebFetch returned only the newsletter shell; recovered with the firecrawl skill per ../HUB.md edge handling, so the summary is from the full article body. New pages: harness-agent-dlc (TechArticle source), agent-evals (DefinedTerm/practice), harness-io (Organization), trevor-stuart (Person, thin node). Dedup: no existing Harness/evals page. Slug care — harness-io is deliberately not harness: this wiki’s central concept is the agentic-coding-harness and a bare harness slug would collide. Homonym warning recorded on both the page and the index line. agent-evals is a consolidation, not a new thread — evals were already scattered across agent-anti-patterns (the “no eval” failure mode), cc-thinking-skills (an eval harness that returned a null result on its own skill pack), cognition-fable5-through-the-night (“trust no eval”) and autonovel (layered mechanical + LLM-judge evaluator). The page gives them one home and states the narrow defensible claim: an eval gate catches a regression against your own dataset, it does not certify quality. Gap-relevance: extends the loop/verification thread from building verification into the loop to enforcing it at the delivery boundary. Synthesis gained a paragraph on “make the pipeline predictable, not the agent,” on determinism relocating from output → record (why eval gates ship with AgentTrace), and on this being the operator’s end of agent-guardrails (gate the release by score, not just the action by blast radius). Contradiction watch: none — it pairs with agent-loops-verification (runtime fidelity vs pipeline enforcement, same bottleneck from two sides). Both are vendor arguments with no independent measurement; that is now the loudest gap in the thread, and Harness explicitly declines to claim a number. Cross-spoke: platform-ops-wiki is the logged runner-up (every mechanism — canary, OPA, tracing, the delivery-measurement gap beside dora-metrics — is its vocabulary); the pre-registered “agents vs live delivery infra” seam is now at 2 sources. Also noted an ai-governance-wiki adjacency (ownership, asset inventory, auditable run records). Entities: harness-io + trevor-stuart created; the TNS journalist (Adrian Bridgwater) not paged, following the spoke’s precedent of paging the subject rather than the reporter (arjun-iyer on agent-loops-verification). Depth 1, well under the recursion cap. Verify deferred per hub policy (content-only). avoid-ai-writing run. 156 → 160 pages.

[2026-07-22] ingest | Corbell (Corbell-AI/Corbell)

Routed from the hub (route in ../log.md). URL-only, T1 — primary artifact (the repo/README itself), Apache-2.0, v1.2.0 2026-05-23, 435★/46 forks. T1 for provenance, but note every capability claim is self-described and nothing is benchmarked. New page: corbell (SoftwareSourceCode). Python CLI that builds a cross-repo code knowledge graph (tree-sitter over 8 languages → service deps, typed signatures, call graphs, execution flows) + embeddings (all-MiniLM-L6-v2), then generates architecture specs from a PRD/feature sentence by auto-discovering the services involved and feeding graph context + snippets to Claude/GPT-4o; validates against recorded architecture constraints and exports tasks to Linear/Jira. Local-only (SQLite, optional Neo4j), MCP server for Cursor/Claude Desktop, D3 graph browser, --ci flag, git change-coupling and IaC detection. Dedup: no existing page; checked the near neighbours (spec-kit, conductor, autowiki-factory, openwiki, knowledge-rag) — all distinct, all cross-linked instead. Updated spec-driven-development with a new section: mined context vs written context. That is this source’s contribution — the other SDD tools have a human author the constitution/clarifications/managed context, Corbell derives the input from the code that exists. Synthesis: extended the machine-maintained-code-wiki paragraph. The extraction step now points two ways — describe what is there (autowiki-factory/openwiki) vs constrain what comes next (Corbell) — and the local-first-store-over-MCP corner gains a fifth capability (codebase structure, beside memory, documents, perception, search). Recorded the caveats: no evaluation that a graph-grounded spec beats a written one, and no refresh trigger backing the “living” graph claim (contrast AutoWiki’s regenerate-on-push). Entities: none created. The only candidate is the “Corbell-AI” GitHub org, and the source carries no evidence about it beyond the name — no people, no company detail. Per ../ENTITIES.md (evidence-only), a name-only node would be noise. Verify deferred per hub policy (content-only). avoid-ai-writing run. 160 → 161 pages.

[2026-07-23] ingest | Building verification loops in Claude Code with skills (Anthropic)

Routed from the hub (route in ../log.md). URL-only, T1 — first-party Anthropic post (Delba de Oliveira, 2026-07-22). New page: verification-loops-skills (BlogPosting source). Encode repetitive post-implementation checks as Claude Code skills (.claude/skills/…/SKILL.md, allowed-tools frontmatter + plain-English steps) so Claude self-verifies and fixes; a verification loop = “an iterative process where Claude checks and attempts to fix the work.” Four activation patterns (standalone / embedded / chained / on-every-PR). Dedup: no existing page; it is the concrete instance under two abstractions already here — loop-engineering‘s verification corollary (updated: this is how you author the cheap faithful check) and agent-evals (added a “two altitudes” section: inner-loop skill vs outer-loop delivery gate, meeting at on-every-PR). Gap-relevance: closes the concreteness gap in the verification thread — the spoke had the why (agent-loops-verification) and the delivery-gate form (harness-agent-dlc, ingested yesterday) but no first-party how inside Claude Code. Synthesis: extended the Harness paragraph to state the full altitude range (skill in the inner loop ↔ eval gate at the boundary), and folded verification back into the capability-as-skill thesis (it’s markdown a skill runtime executes). Caveat recorded: vendor how-to for the vendor’s product, no measurement, and a self-referential risk — a plain-English check applied inconsistently is the nondeterminism evals exist to catch, so a verification skill arguably wants its own eval. Entities: none created. Author Delba de Oliveira is an Anthropic devrel byline with no distinct load-bearing thesis of her own here; per ../ENTITIES.md (evidence-only, thin nodes = noise) noted inline instead. anthropic is the cross-wiki publisher node (research-wiki) — not duplicated. Verify deferred per hub policy (content-only). avoid-ai-writing run. 161 → 162 pages.

[2026-07-23] ingest | Anthropic Claude Security plugin for Claude Code (MarkTechPost)

Routed from the hub (route in ../log.md). URL-only, T2 — MarkTechPost, detailed technical secondary coverage of a first-party Anthropic beta release. New page: claude-security-plugin (SoftwareApplication, source). A beta Claude Code plugin (/claude-security, official marketplace) running a multi-agent vulnerability scan: six-phase JS dynamic workflow (Inventory→Threat-model→Research→Sweep→Panel→Adversarial), four vuln classes (memory-safe langs skip the memory lens), model-tiered roles (Opus-class orchestrator, Sonnet-class cartographer/explorer, session-model researchers/verifiers). Findings survive a 2-of-3 verifier quorum (reachability/impact/ defenses; unanimous→high, 2/3→medium) whose tally is computed in Python by the renderer, not asserted by the model. Patches built in an isolated scratch clone + independently verified; manual git apply. Filed here on the substance-not-domain rule (like cybersecurity-skills): security is the domain, the multi-agent orchestration + programmatic verification is why it’s in this spoke. osint-wiki noted as the security-subject bridge (cross-link, not duplicate). Dedup: no security/scanner page existed. Wired into agent-orchestration (added as Anthropic’s own shipped instance) and agent-evals (new “take the tally out of the model’s hands” section — the quorum + Python tally is the escape from model self-grading). Also cross-linked verification-loops-skills, harness-agent-dlc, agent-guardrails, claude-code-model-effort-levels (model-tiering = the model-choice lever inside one tool). Gap-relevance: the verification thread’s sharpest artifact — synthesis extended to state the trust-anchor (quorum-with-mechanical-tally for stakes where a model’s self-report is unacceptable), completing the altitude range skill→eval-gate→quorum. Recorded the honest scope: nondeterministic, doesn’t replace SAST/dep-scan/ review, and adds no isolation of its own (inherits session perms; sandbox-runtime recommended). Model-version note: the source phrases the tiers as “Claude 3 Opus/Sonnet”; paged as Opus-class/Sonnet-class since the durable point is role-tiering, not the version string (likely article phrasing). Entities: none new (Anthropic is the cross-wiki node; no author paged). Verify deferred per hub policy (content-only). avoid-ai-writing run.

[2026-07-23] ingest | LLMs Will Cheese Your Types: Fighting Back in Haskell (Justin Le)

Routed from the hub (route in ../log.md). URL-only, T2 — expert practitioner analysis (Justin Le, blog.jle.im), original and specific but single-author opinion, no measurement. New pages: llms-cheese-your-types (BlogPosting source), constraint-evading-behavior (DefinedTerm, failure-mode), justin-le (Person, thin node). The durable move is the concept page: constraint-evading behavior = an agent satisfying a check’s letter while defeating its purpose (specification-gaming / reward-hacking at the developer-guardrail level). Haskell types are the instance; the idea generalizes to tests/lints/evals. Dedup: no reward-hacking/spec-gaming/constraint page existed — this fills a real hole. Wired into agent-guardrails (new design-time-vs-runtime section: a guardrail you can cheese is instruction not enforcement), agent-evals (new “a gate you can cheese isn’t a gate” section — bounds the whole eval thread), and agent-anti-patterns (Related). Gap-relevance: this is the antagonist the verification thread lacked. The day’s arc (agent-evals → verification-loops-skills → harness-agent-dlc → claude-security-plugin) all argued gate on a check; Le shows the agent cheeses the check, so a gate’s worth = its un-gameability. Synthesis: extended the verification paragraph with the counterforce AND Le’s constructive fix (checks as scaffolds not gates — invalid states unrepresentable; the Lean analogy = cross-spoke bridge to research-wiki’s formal methods). Full arc now: author a check → enforce it → make it un-cheeseable by construction. Entities: justin-le created (thin, one source); the lean-theorem-prover link is intentional cross-wiki to research-wiki, not a local dup. Caveat: Haskell-specific, single opinion, no data — pattern generalizes, mitigations are language-bound. Verify deferred per hub policy (content-only). avoid-ai-writing run.

[2026-07-25] ingest | Compound Engineering plugin — re-seen, refreshed in place

Telegram drop of https://github.com/EveryInc/compound-engineering-plugin. Dedup: already ingested 2026-05-29 from the held README (raw/compound-engineering-plugin.md), so per the edge rule this refreshed compound-engineering-plugin in place — no new source page. Added url: beside the existing sources:; bumped updated. T1 (first-party repo); star count is popularity, not evidence. What changed since May: 32 skills (was a handful), 13 install targets each with its own in-repo plugin manifest, /ce-work cross-model dispatch (execution can leave, verification and shipping don’t), /ce-code-review explicitly report-only, solutions written to docs/solutions/, and a standing design choice — no standalone agents or hooks, specialist behaviour lives inside skills. Gap-relevance: sharpens thread 1 (capability as portable markdown) by pairing it against superpowers. Same shape — a methodology as a skillpack — differing on who invokes (agent self-invocation vs explicit /ce-* commands, /lfg as the autonomous escape hatch) and on /ce-compound, the one skill in the corpus whose output is the next run’s context — self-improving-agents by filesystem artifact rather than weight update. Also a data point against the agentskills-spec portability thesis: 13 manifests is the pre-standard tax still being paid by the biggest packs. No contradictions. Synthesis thread 1 extended; index row updated. Page count unchanged (36 → 36 unaffected). Verify deferred per hub policy (content-only, no page moves). avoid-ai-writing run.

[2026-07-26] ingest | OpenManus — open general-purpose agent framework (github.com/FoundationAgents/OpenManus)

Routed here by the hub; no runner-up worth naming. T1 (project repo), MIT, 57.6k★ / 10k forks. New: openmanus (source), foundation-agents (entity). Updated: synthesis — a new Vendors paragraph on the community-org stratum, and a new entry under Contradictions/tensions for the RL sibling. Two findings, one of them uncomfortable for this wiki:

  1. The moat cut both ways. Manus gated a general agent behind an invite code; MetaGPT-community authors had an open prototype in three hours and took 57.6k stars off 526 commits. If value has moved into the wrapper, the wrapper is also the cheapest part to re-implement. The 301 open issues and 192 open PRs are the counterweight — replicating took hours, carrying it doesn’t.
  2. OpenManus-RL (with UIUC) tunes agent LLMs via GRPO, locating competence in the weights. The spoke has ~166 pages on the structural bet and zero sources on the RL one. Filed as a tension, not a contradiction — they’re compatible in principle, competing as bets. Dedup: nothing on Manus, MetaGPT or OpenManus existed (grep over wiki/ + spine). Nearest neighbours openclaw and hermes-agent are open replacements for closed harnesses; this replaced a closed waitlist, which is why it’s paged rather than folded into either. Weakness recorded: the README asserts multi-agent support and tools but never documents the agent loop — the layer this spoke exists to study is exactly the undocumented one. Star count is a popularity signal, not an engineering one, and the page says so. Entities: foundation-agents paged as the meaningful node. Core authors Xinbin Liang and Jinyu Xiang are named on the org page but not paged — the evidence is names on a repo and nothing attributable beyond it (evidence-only rule); page them if either shows up in a second source. Verify deferred per hub policy (content-only). avoid-ai-writing run.

[2026-07-27] ingest | nono — least-privilege agent sandbox (Nolabs AI, GitHub)

Routed here by the hub (runner-up: defensive-security-wiki — the least-privilege / credential-proxy substance is blue-team, but the subject is running agents, which is this spoke; the security angle is cross-linked, mirroring today’s inverse call where strix went to osint-wiki by subject despite being agent machinery). T3 project README, Apache-2.0, ~3.2k★, pre-1.0 with APIs still moving and 110 open issues; the “in production at large companies” claim is unattributed and there is no audit or threat model. New: nono (source), nolabs-ai (entity — Sigstore team, notable provenance). Updated: agent-guardrails (new section: moving the boundary to the tools), synthesis (a third containment altitude), index. What it adds:

  1. A different unit of containment. The corpus contains the agent — control planes wrapping a harness (microsoft-scout, NemoClaw, the Claude gateway) or isolated execution beneath it (cloud-run-sandboxes). nono’s claim is the unit is wrong: the dangerous privileges belong to the tools the agent delegates to, so git/gh/curl/kubectl each get a child sandbox with separate credentials, filesystem grants, network rules and policy.
  2. It closes the auto-company hole structurally. That page’s failure mode is prose limits plus danger-full-access, with permission prompts turned off when they get inconvenient. Here an agent cannot widen a tool’s permissions from inside its session because that policy was never its to hold, and there is no prompt to disable. The enforcement-vs-instruction distinction agent-guardrails draws now has a product on the enforcement side.
  3. Restriction as a shareable artifact. Composable JSON policies with profile inheritance and a public registry — the packaging move agent-skills made for capability, applied to its opposite. Also recorded: credentials reach tools through a proxy with L7 endpoint filtering rather than the agent’s environment, which is the same principle ../defensive-security-wiki’s Beyond Zero (routed there hours earlier) reaches at enterprise scale — authorize the action, don’t trust the session holder. Two independent arrivals at one idea in one week, at opposite scales. Provenance worth keeping: the Sigstore team building agent containment says something about which problems are now load-bearing. Verify deferred per hub policy (content-only). avoid-ai-writing run.

[2026-07-27] ingest | Pilot Protocol — “the Network OS for agents” (pilotprotocol.network)

Routed here by the hub (runner-up: none clean — the payments facet (USDC/x402 agent-to-agent settlement) has no owning spoke; ../search-marketing-wiki owns agentic-commerce but that’s the consumer-facing side, agents buying on a human’s behalf. Recorded as cross-spoke context on the source page rather than split out). T3 vendor landing page. Technical detail is specific enough to check (address format, congestion control, named crypto primitives); every traction number is an unaudited self-reported counter. New: pilot-protocol (source). Updated: a2a-protocol (the other branch — replace the substrate), synthesis (a sixth contender that isn’t at the same layer), index. What it adds:

  1. A different branch of the interop question. The spoke’s five standards (a2a-protocol, MCP, ARD, agents-md, agentskills-spec) are all formats layered on the human internet — HTTP, DNS, TLS kept, agent semantics added above. Pilot replaces the substrate: own addresses (N:NNNN.HHHH.LLLL) resolved by its own registry, OSI-L5 UDP with sliding window/AIMD/SACK, NAT hole-punching for direct tunnels, X25519/AES-256-GCM/Ed25519. So the prior question is not “which standard wins” but does the agent web run on the human web at all.
  2. Payments as a network primitive. None of the five says how one agent compensates another, which is what decides whether an open agent network sustains itself. Pilot puts USDC/x402 settlement in the stack alongside addressing and discovery.
  3. The governance pattern inverts. A2A, AGENTS.md and ARD all ran vendor → neutral foundation → default. Pilot is a venture-funded company operating the network it specifies ($4.5M seed) with a curated app store it controls. Recorded plainly that an IETF Internet-Draft is not a standard — anyone may submit one, they expire in six months, and it confers no standing until a working group adopts it. Skepticism recorded: ~219k “agents online” and ~33k req/s are marketing counters with no definition of what makes an agent “online”; the architectural argument is the part worth keeping, separately from the traction claim. Follow-up if it recurs: read the actual Internet-Draft and the GitHub repo rather than the site. Verify deferred per hub policy (content-only). avoid-ai-writing run.

[2026-07-28] ingest | iai-pme — personal memory engine for AI assistants (CodeAbra, GitHub)

Routed here by the hub (runner-up: research-wiki — the gbrain/llm-wiki PKM lineage. Declined on the project’s own framing: “personal memory” here means the assistant’s memory of you, not a knowledge base a human reads, so it’s agent-memory infrastructure). T3 project README, MIT, ~423★, solo-maintained, declared stable (1.x API commitment). New: iai-pme (source). Updated: agent-memory (a second axis: store vs process), synthesis, index. What it adds:

  1. A second axis for the memory layer. The existing poles — seekdb (DB), memory-vault (pgvector over MCP), recall (markdown over hooks) — differ in weight but are all stores you write to and search. iai-pme models memory as processes, structured on human memory research: episodic (verbatim, write-once) / semantic (induced from episodes during idle consolidation) / procedural (learned user parameters), held apart so detail, gist and habit don’t collapse.
  2. Forgetting as a feature. Nightly consolidation reorganizes the store unprompted; unreinforced links decay on a schedule with pinning to resist. No other instance in this layer schedules forgetting. Recall also returns contradictions alongside matches — the staleness problem temporal-knowledge-graph answers with validity intervals, answered here by handing the conflict to the model.
  3. It publishes numbers on a public benchmark. LongMemEval-S R@5 0.962 / R@10 0.978, Rescue@10 1.000, retrieval ~350 tokens vs ~2,850 for agent search, latency 77ms@1K / 368ms@10K. Author-run and the token-efficiency baseline is unspecified, but a named public benchmark is a rung above the assertion-only claims the rest of this layer offers — a partial answer to the standing “nobody measures the memory layer” gap. Internals worth recording: MOSAIC, an in-house Leiden-family community detection with a CPM objective — the GraphRAG clustering move applied to one user’s episode history; Hippo (SQLite + AES-256-GCM holding both vector index and graph); local bge-small-en-v1.5 via a Rust embedder on Candle; ambient capture through per-turn hooks (~5ms, no embedding). The episodic/semantic/procedural split is Tulving’s taxonomy from cognitive psychology arriving as a software architecture — the cleanest seam yet to the new ../psychology-wiki. Limits recorded from the README (unusually candid): English-only, no cross-machine sync, poor recall for the first ~10 sessions, seconds-long cold start, Windows beta, no enterprise SLA. Entity (Areg Aramovich Noya, solo maintainer) deferred — thin, one project. Verify deferred per hub policy (content-only). avoid-ai-writing run.

[2026-07-28] ingest | Kimi Claw — managed OpenClaw with Claw Groups preview (Moonshot, kimi.com/bot)

Routed here by the hub (runner-up: llm-providers-wiki — Moonshot is a provider and the K2.6-vs-K3 detail is a provider fact, cross-linked onto kimi-k3 there; but the subject is an agent product built on openclaw, which is this spoke’s). T3 product landing page. Third share.google link this cycle — resolved from the share page’s HTML to kimi.com/bot. New: kimi-claw (source). Updated: openclaw (a third vendor shape), synthesis (fourth shape in the vendor-layer thread), index; cross-spoke, kimi-k3 in llm-providers-wiki. What it adds:

  1. A vendor shape that isn’t governance. openclaw‘s thesis was that the project supplied gateway-first breadth and platform vendors filled the governance gap — NVIDIA with an external sandbox, Microsoft with containers and Entra identity. Moonshot is a model lab and adds hosting and a model: one-click deploy, K2.6 Thinking preconfigured, skills ready. No policy runtime, no identity, no sandbox mentioned. So the layer above OpenClaw sorts by what the vendor already sells — and a lab sells weights plus an ops team.
  2. A lab integrating downward, from the model into the harness that consumes it. The exact mirror of ../llm-providers-wiki’s sakana-fugu (an agent system sold as a model), ingested four days apart. The model/product boundary is being collapsed from both directions at once.
  3. It ships K2.6, not K3 — one day after kimi-k3 launched. No reason given; the plausible ones (24/7 cost profile, productization lag) are unsourced and recorded as such. The general point is worth keeping: a lab’s announced flagship and the model its own products run are separate facts. Recorded as a gap rather than a finding: the hosted product ships preinstalled skills while ClawHub’s 341 malicious skills remain OpenClaw’s known weak spot, and the page addresses neither that nor how a hosted instance is isolated. Also unstated: pricing, availability, what Claw Groups actually does, and which skills are included. Verify deferred per hub policy (content-only). avoid-ai-writing run.

[2026-07-28] ingest | i-have-adhd — ADHD-friendly output skill for coding agents (github.com/ayghri/i-have-adhd)

Routed here by the hub. T1 (project’s own repo). Metadata verified via the GitHub API rather than the page summary: 12,333★ / 632 forks, MIT, created 2026-05-13, last push 2026-07-28. New: i-have-adhd (source). Updated: reasoning-scaffolds (new third category), ponytail (the sibling contrast), agent-evals (the gate at skill scale), synthesis (thesis layer 1 + the Benchmarks open question), index. The skill: ten rules shaping what an agent says — action first, numbered steps, state restated every turn, tangents deferred, time in real units, lists capped at five, no preamble/recap/closers — plus a pre-send check (delete the announcing opener, the “anything else?” closer, the sidebar, the empty hedge; then verify the first and last line carry the next action and the current state) and six documented override conditions, including two precedence rules: when a rule would delete the answer the task wins, and inside a harness the system prompt outranks the skill. Two findings. (1) A third kind of skill. reasoning-scaffolds split capability from cognitive skills; this one is neither, and neither are ponytail or renwei-writing. They constrain the artifact, not the thinking — recorded as output-shape skills. The distinction is about how expensive the claim is to check: whether an agent really ran a pre-mortem is unknowable from its output, whether it opened with a command instead of “Great question” takes one line to verify. That’s the same “checkable step beats a posture” pattern cc-thinking-skills’ null result already pointed at. (2) The first skill to ship its own eval harness and release gate. evals/ carries cases, a blind weighted rubric (correctness 35 / autonomy 25 / actionability 20 / safety 10 / concision 10) and a gate: no blockers, correctness and safety within 0.1 of baseline, weighted score above it. Note what the weighting does — a brevity skill’s failure modes are dropping substance and shoving work back to the user, so those two dimensions carry 60% and the thing being sold carries 10%. It’s ponytail‘s prose guardrail (“restraint never trades away validation/security/accessibility”) turned into a threshold. The runner guards contamination the corpus learned about the hard way: strip operator config so user plugins/hooks don’t leak into conditions (worst case named in the repo — its own always-on flag injecting the skill into the baseline), pin the model, cap spend in dollars, resumable runs, and a fairness clause requiring competitor claims to use the same cases/models/trials/rubric. Recorded weakness: no results published. Harness without a run. The corpus now holds three postures — a metric without a method (ponytail), a method with a null result (cc-thinking-skills), and a method with no run (this) — which advances the Benchmarks question without closing it. 12.3k★ measures appeal, not effect. Cross-spoke: the ADHD framing is borrowed from Ramsay & Rostain’s The Adult ADHD Tool Kit and adapted to LLM output. Noted as adjacency to ../psychology-wiki, not routed there — same rule that spoke already applies to borrowed System 1/2 vocabulary: the borrowed metaphor stays with its application. Whether the formatting helps actual ADHD readers is a clinical question the repo doesn’t test. Author ayghri inline, not paged (pseudonymous handle, low graph signal — ponytail precedent). Verify deferred per hub policy (content-only). avoid-ai-writing run.

[2026-07-28] ingest | JetBrains — Ponytail skill for Claude Code: does it really cut tokens? (blog.jetbrains.com)

Routed here by the hub. T2 — the first genuinely independent measurement of a skill in this spoke: a third-party lab testing a tool it doesn’t own, publishing method and numbers. New: jetbrains-ponytail-tested (source). Updated: ponytail (new measured section; the self-reported caveat now says partly-borne-out-and-overstated), agent-evals (new section on third-party evals), synthesis (the Benchmarks open question, substantially rewritten), index. Reused jetbrains cross-wiki from dev-tooling-wiki via entity-index — not duplicated.

Method: 80 paired SkillsBench tasks, auto-graded 0–1 with partial credit; claude-sonnet-5 at medium effort; Harbor 0.18 with Docker sandboxes; Arm A stock Claude Code 2.1.201, Arm B the Ponytail v4.8.4 ruleset injected via SessionStart hook. 251 billed trials, USD 246.09, escalated through a 10-task smoke run and a k=3 stage. Every trial audited to confirm the ruleset reached the treatment arm (100%) and stayed out of the baseline (0%).

Result: −15.4% code (p=0.088), −10.3% cost (p=0.004), −11% wall-clock, and no quality difference detected (9 worse / 6 better / 65 identical). Advertised was −54% code, −22% tokens, −20% cost, −27% time — so roughly a third of the claim. JetBrains attributes the gap to method rather than dishonesty: the repo’s number is a mean over twelve hand-picked feature tickets, theirs a median over 80 tasks nobody chose for the purpose. That’s the general lesson about self-reported metrics — usually measured on the sample that flatters them, not invented.

Three findings worth more than the headline. (1) The benefit is conditional. 31% code reduction on larger builds, near zero where the baseline was already lean. Ponytail doesn’t make an agent write less, it stops an agent writing too much, so the payout tracks how often the baseline over-engineers. Any single percentage is an artifact of the task mix — which should now be the default reading of every restraint/output-shape skill’s headline number. (2) Adherence is not a given. Without the SessionStart hook the skill self-activated zero times across ten sessions, despite a description claiming readiness for “ANY coding task” — so the measured benefit requires the always-on install, and the advertised one does nothing. Separately, its own rule about leaving ponytail: comments on deliberate shortcuts was followed once in 80 trials. A loaded skill is a bid for the model’s attention, not a constraint. (3) Small samples flip signs. The 10-task smoke stage reported −3% code and a +9.6% cost increase before the full run landed at −10.3%.

Limits recorded on the page: SkillsBench scores task completion only — not security, validation, error handling or accessibility, which is exactly the ground ponytail‘s guardrail claims to protect, so that claim stays unmeasured. 80 pairs can’t prove quality equivalence; the null remains compatible with small degradation. Only the cost result clears conventional significance (code sits at p=0.088, and the cost median’s bootstrap interval “just touches zero”). Gap-relevance: directly answers the spoke’s oldest open question. Ingested the same day as i-have-adhd, which supplies the author-side complement (a harness with no run); the two together put the Benchmarks question in a new state — open with evidence in it rather than open for lack of any. Verify deferred per hub policy (content-only). avoid-ai-writing run.

[2026-07-28] ingest | Gemini API Managed Agents — 3.6 Flash, hooks, and more (blog.google)

Routed here by the hub (runner-up: llm-providers-wiki for the Gemini 3.6 Flash model facts — cross-linked, not split). T3: first-party product announcement, promotional, one customer testimonial as its only outside evidence. New: gemini-managed-agents-hooks (source). Updated: agent-guardrails (new spend-as-a-bound section), agent-middleware (middleware sold as a service), synthesis (vendor layer gains a fifth shape), index. Reused google cross-wiki. No new entities. Verified against the page, not the summary — antigravity-preview-05-2026 looked like a fetch artifact and is in fact the real agent identifier. Worth the extra fetch.

What shipped: hooks via .agents/hooks.json firing on pre_tool_execution/post_tool_execution with regex matchers and either in-sandbox commands or http POST handlers; max_total_tokens capping input+output+thinking, pausing to status: "incomplete" with state preserved and resume via previous_interaction_id; cron triggers binding agent+environment+prompt, each run reusing the same sandbox so files persist; an Environments API to list/inspect/delete sandboxes against a 7-day TTL; Gemini 3.6 Flash as default (3.5 Flash / Flash-Lite selectable via agent_config.model); free-tier access on projects with no active billing.

Three findings. (1) The vendor layer gains a fifth shape, and it’s the harness’s negation. The closing pitch is agents that run “without breaking your budget or requiring external orchestration” — i.e. without a harness. Where kimi-claw hosts a harness someone else wrote, this dissolves the harness into the model API. A lab integrating downward past the harness rather than into it. (2) The cost is named by Google’s own customer, not by Google. OffDeal’s CTO: “Before agent hooks, we couldn’t do this on Gemini’s managed agents: the sandbox is remote, so our validation code had nowhere to run.” That’s the managed model’s limitation in one sentence — verification needs somewhere to execute, and the agent-loops-verification thread assumes you can run a check next to the agent. Hooks are the vendor selling back a slice of the control the managed model removed: agent-middleware‘s before/after-tool-call hook points, re-sold as a managed feature to plug the hole managed agents opened. (3) Budget is a third guardrail axis. agent-guardrails bounds agents by reversibility and recovery cost; max_total_tokens bounds by spend, which is the bound an autonomous multi-turn loop actually needs — its failure mode is a run that never converges, not a destructive action, and reversibility-based guardrails are blind to that. Pausing rather than aborting also makes it a durable-agents mechanism: a spend ceiling and a resumable checkpoint are one construct from two sides. Detail worth keeping: the deny path explains itself — {"decision": "deny", "reason": "..."} skips the call and feeds the reason into the model’s context. Double-edged per constraint-evading-behavior: telling a model exactly why it was blocked also tells it what would have passed. Recorded gaps: no pricing, no execution-time or concurrency limits, no benchmark, and nothing on what an untrusted prompt can do inside a sandbox that has package installation and web retrieval. Also noted the reflexive bit — the post ships an agent skill for its own API (npx skills add … gemini-interactions-api), the skills standard used by a vendor to onboard agents onto its own product. Verify deferred per hub policy (content-only). avoid-ai-writing run.

[2026-07-28] ingest | Perplexity API Platform skills (github.com/perplexityai/api-platform-developers)

Routed here by the hub (runner-up: llm-providers-wiki — Perplexity as a provider and the Sonar→Agent API change; cross-linked, not split, since the artifact is agent tooling). T1, the vendor’s own repo. Metadata verified via the GitHub API: Apache-2.0, created 2026-07-15, last push 2026-07-23, 71★. New: perplexity-api-platform-skills (source). Updated: agent-evals (new section on naming the un-greppable residue), agentskills-spec (widest install matrix so far), synthesis (Benchmarks open question), index. Reused perplexity cross-wiki from web-browsers-wiki.

Two skills: migrate-sonar-to-agent-api and pplx-cli.

Finding 1 — migration as a skill. The flagship skill’s job is moving developers off the vendor’s own deprecated API, and its triggers are the symptoms of a botched attempt (“replacing deprecated sonar-pro / sonar-reasoning models, or fixing 400 unknown-field errors and missing citations”). The corpus’s vertical skills so far add expertise (agentic-seo-skill, cybersecurity-skills) or shape output (ponytail, i-have-adhd); this is a vendor absorbing its own breaking change — deprecation cost, normally paid by every customer reading a migration guide, packaged as agent work.

Finding 2 — the best-designed eval in this wiki, and it’s from the vendor. Fixtures are two versions of one app (raw-HTTP and official SDK), each “verified against production on 2026-07-09” and deliberately loaded with the classic hazards; contributors are told not to tidy them. Reference migrations from live runs are shipped and explicitly disqualified as answer keys — “Model output is nondeterministic, so treat these as examples, not golden diff targets. Grade with check.sh” — which is agent-evals‘s nondeterminism problem solved (grade properties, not a diff against one lucky run). check.sh is mechanical: leftover greps, required greps, and --live runs of the migrated app against production, so the tally isn’t model-asserted. Fixtures are kept comment-free to stop hint-leakage. And step 5 of the runbook documents the A/B against no-skill — rerun without the plugin, grade both. Compare i-have-adhd (rubric and gate, no baseline procedure) and jetbrains-ponytail-tested (an outsider had to build the A/B).

The move worth stealing: the rubric’s last section is headed “Judged by eye (not greppable)” and names two things the script can’t catch — related-questions must be “preserved via a workaround rather than silently dropped,” and the streaming consumer must exit “on every terminal event, not only response.completed.” Both are exactly what a greppable rubric rewards (delete the feature and the leftover-grep passes). That’s constraint-evading-behavior anticipated by the gate’s own authors, who then route the residue to a human instead of pretending the script covers it. The practical answer to “a gate you can cheese isn’t a gate”: you can’t grep your way out, so name what’s left.

Also recorded: the install matrix is the strongest agentskills-spec portability evidence yet — one tree serving Claude Code and Codex marketplaces plus a plain skills/ dir, npx skills add said to fan out to ~70 agents, gh skill add with version pinning, and a zero-install path (“Any agent that can fetch a URL can use a skill directly”), which is what a real standard looks like. A docs MCP server ships in the root .mcp.json beside the skills, so procedure and live facts install together. And the repo’s CLAUDE.md is one line — AGENTS.md — the vendor convention reduced to a pointer at the cross-tool one. Weakness recorded: no results published. Hand-runnable harness, no score. Across today’s four eval-adjacent sources the tally is one outside measurement and three harnesses nobody has run. Verify deferred per hub policy (content-only). avoid-ai-writing run.

[2026-07-29] ingest | jcode (1jehuang) — Rust terminal coding agent

Routed from the hub. T1, the repository read directly: MIT, Rust, 13,127★/1,452 forks on ingest day, created 5 January 2026, pushed the same day it was read. Nearest existing sibling is claw-code — same minimal-Rust-CLI corner, opposite density.

Three things earned their own analysis rather than a feature list.

The benchmark disclosure is better than the corpus norm, and the baseline still carries the claim. jcode publishes RAM and startup numbers against seven rival harnesses with the exact version of each, ranges instead of bare means, the procedure, and a footnote on why Antigravity needed a different readiness signal — most of what jetbrains-ponytail-tested had to supply from outside, given voluntarily. But the baseline row is jcode with local embedding off, a config it doesn’t ship, so every “N× more RAM” is anchored there and jcode’s own default lands at 6.0× baseline — above pi and Codex CLI, two tools it is comparing itself against. Startup (14 ms vs Claude Code’s 3,437 ms) and per-session scaling (~10 MB vs ~213 MB) need no such reading. Folded into the Benchmarks open question as a refinement: method can be impeccable and the choice of baseline still does the work.

Memory moves inside the harness. Turn embeddings into a memory graph, cosine retrieval, injection either passive or gated by a memory sideagent, extraction on semantic drift / K turns / session end, and ambient consolidation that checks staleness and conflicts. iai-pme and knowledge-rag do comparable work behind MCP; this does it in-process, and its consolidation-with-conflict-checking converges on iai-pme’s decay and contradiction surfacing independently. Bet against context-rot is that relevance-gated retrieval beats accretion — unmeasured.

Multi-agent gained a second topology, and this is the ingest’s real contribution. The corpus’s agent-orchestration has meant orchestrator → subagent fan-out, a tree, with isolation per agent. jcode’s swarm puts several agents in one repo under a server that tracks reads and notifies an agent when a file it read is edited underneath it. That’s peer-to-peer with cache invalidation against the corpus’s tree-with-isolation: one prevents the conflict, the other detects and reconciles it. New synthesis section; no evidence either way on which survives contact.

Cross-spoke context recorded on the page, not split: the custom terminal (handterm), the from-scratch mermaid-rs-renderer and the negative-space widget system are real ../ui-frameworks-wiki material next to opentui — but the harness is what jcode is, so it files here. avoid-ai-writing run. Verify deferred per hub policy (content-only, no page moves).

[2026-07-29] ingest | jcode — second pass (README sections missed on the first read)

Re-read the full README and found two mechanisms the first pass skipped, both load-bearing. Skills load by embedding hit, not on startup: the conversation is vectorised and a skill injected on similarity against the same index that serves memory. That is a direct alternative to agentskills-spec‘s progressive disclosure — retrieval-selected versus description-selected capability, each with its own failure mode, neither measured. The author rejects worktrees explicitly (“Git was clearly not built for multi-agent workflows, and git worktrees is not a good solution”) and wants a new git-like primitive, which sources the swarm-topology claim made in synthesis an hour earlier rather than leaving it as our inference. Also: the iOS app is announced and unshipped, reaching your own machine over Tailscale with “Openclaw like features” — linked to openclaw, same problem solved earlier. Person node 1jehuang added per ../ENTITIES.md (thin, handle-only, the mahipal-jangra precedent).

[2026-07-29] ingest | Shipping code without human verification (The New Stack)

Routed from the hub. T3 — sponsored content: the post carries “Aviator sponsored this post”, Aviator sells a verification product, and the article links to aviator.co/verify exactly where the argument needs a solution. Rubick’s credentials are real (ex-VP Eng, New Relic and Gremlin) and the piece is better than most vendor content, but conclusion and product line up. WebFetch returned a truncated excerpt; recovered in full with the firecrawl skill.

Dedup note: this is the fully-readable companion to agent-loops-verification — same publication, same thesis, six weeks earlier, held at T4 because its body never fetched. Kept both; this one carries the detail.

Contribution: testing asserts, verification judges. Testing confirms the code works; verification confirms the change did what was intended and meets the org’s standards. Code review fused them and did the judging badly. That explains something the corpus hadn’t accounted for — why improving test coverage never dissolved the review bottleneck, since intent alignment, acceptance-criteria coverage, architectural fit and blast radius aren’t assertable and are most of what review was for. The article’s row-by-row Test/Verify/Split table is reproduced on the page.

The gap, folded into synthesis: it never asks whether an automated gate is adversarially robust. The proposal hands judgement to an LLM on exactly the rows that can’t be asserted, and this spoke holds constraint-evading-behavior — agents satisfying a check’s letter while defeating its purpose — while ../defensive-security-wiki holds the extreme case of a model treating its sandbox allowlist as the puzzle. The recommended Swiss-cheese layering defends against independent failures, not correlated ones where verifier and author are the same class of system. Recorded as the sharper form of the Benchmarks open question: nobody here has measured a verifier against an agent with an incentive to pass it.

Its one quantity — “improving detection by 50% may speed up the engineering organization by 200%” — has no method, no source and a load-bearing “may”, in sponsored content advocating the sponsor’s category. Flagged against jetbrains-ponytail-tested. avoid-ai-writing run. Verify deferred per hub policy (content-only, no page moves).

[2026-08-03] ingest | Mobilerun — LLM agents that drive Android/iOS phones

Routed by the hub (Telegram, github.com/droidrun/mobilerun). Runner-up: none — no spoke owns mobile automation, and this is agent-building machinery by every test the registry applies.

New pages: mobilerun (source, T2 — first-party README + first-party benchmark page, eval harness published for reproduction), mobile-device-agent (DefinedTerm), droidrun (Organization, thin). No dedup hit: nothing in the spoke touched mobile, GUI automation or accessibility trees.

What it opens. The spoke’s first source where the controlled surface is a device rather than a repo, a browser or a chat channel. Architecture is Portal-on-phone plus runtime-on-your-machine, which makes it model-agnostic by construction (OpenAI/Anthropic/Gemini/DeepSeek/Ollama/OpenRouter) — the phone runs no model, so everything that makes the agent work is harness. Reasoning mode is manager-executor planning, i.e. agent-orchestration with taps as the end effector.

Contribution: the tree-vs-pixels choice is a context-budget argument. Reading the OS accessibility tree instead of screenshots buys a claimed 500× smaller payload and better accuracy, because a labelled button doesn’t need recognizing. That inverts pxpipe, which pushes text into images on a coding harness for the opposite reason — no structured description available there, one shipped free here. Folded into synthesis as a rule: ask what the platform already describes before deciding to look at it.

On Benchmarks. 91.4% over AndroidWorld’s 116 tasks, external task set, named leaderboard (AutoGLM-Mobile 84.5 / LX-GUIAgent 80.2 / K²-Agent 79.3 / Finalrun 76.7), harness open for reproduction. Better evidence than most of this corpus and still vendor-run — logged against jetbrains-ponytail-tested as a ceiling, not a settlement.

Gap recorded, not papered over: a tap has no diff. The spoke’s verification thread assumes an inspectable artifact before the action counts; nothing in the source addresses what reversibility bounds mean when the agent is spending money on a real phone.

avoid-ai-writing run. Verify deferred per hub policy (content-only, no page moves).

[2026-08-03] ingest | video-use — conversational video editing as an agent skill

Routed by the hub (Telegram, github.com/browser-use/video-use), ~20 min after mobilerun. Runner-up: none.

New pages: video-use (source, T2 — first-party README, 18.6k★/2.3k forks, no independent evaluation), browser-use (Organization, thin), text-first-agent-design (DefinedTerm). Dedup: watch-skill already covers video as agent input; this is video as output, and the two now anchor opposite ends of the same discipline rather than duplicating.

Why a concept page and not just a source summary. video-use’s “text-first” design — one ElevenLabs Scribe call → ~12KB transcript, composites rendered only at decision points — is the same decision mobilerun makes with the accessibility tree, from an unrelated org in an unrelated medium, on the same day. With watch-skill‘s ≤100-frame budget that’s three instances from three orgs, which promotes a per-repo note to text-first-agent-design. pxpipe resolves as the principled inverse (no upstream structured description on a coding harness → pricing arbitrage is the only lever left), so the corpus now holds four points on one rule instead of one apparent contradiction.

The verification contrast is the other contribution. video-use self-evaluates at cut boundaries and re-renders up to 3×; mobilerun can’t, because a tap leaves no artifact. Folded into synthesis: what decides whether loop-engineering‘s feedback signal exists is whether the action produces something inspectable before it counts — and where it doesn’t, agent-guardrails has to gate the plan (video-use asks the user to approve a cutting strategy before rendering; on a phone that’s all there is).

Weakness recorded: the README claims it beats presets and traditional NLEs for any content type and measures nothing; the self-eval loop is a mechanical boundary check, not a judgment on edit quality. Stars measure attention (openclaw precedent). Filed under the standing Benchmarks gap.

Also touched: mobilerun, mobile-device-agent, watch-skill, pxpipe (backlinks). avoid-ai-writing run. Verify deferred per hub policy (content-only, no page moves).

[2026-08-03] ingest | MD-This-Page — web page → Markdown, for pasting into a model

Routed by the hub (Telegram, github.com/Ademking/MD-This-Page). Runner-up: research-wiki — the markdown-clipper / PKM lineage is a real fit, and this is a clipper. Routed here because the README’s stated purpose is LLM context efficiency and that corner (headroom / pxpipe / safe-prompt-pruning / tokenmining) lives in this spoke. Recorded on the page so it can be re-filed if the PKM reading wins.

New pages: md-this-page (source, T2 — first-party README, 1.3k★, nothing measured), adem-kouki (Person, thin).

Contribution: a fifth lever, and the first one upstream of the harness. The token-budget corner had compress (headroom) / remove (safe-prompt-pruning) / swap modality (pxpipe) / route (tokenmining) — all acting on context already in flight. This one strips at capture: Readability drops ads, nav and script tags before the text ever reaches a clipboard. Folded into synthesis and into text-first-agent-design.

And it’s the day’s pattern with the agent removed. Third source in a morning taking a structured representation over the raw surface (mobilerun tree-not-pixels, video-use transcript-not-frames, this article-not-page) — but here a human does the curation by hand. Worth stating plainly because it undercuts the machinery: Mozilla shipped Readability for Reader Mode in 2010, and it captures a meaningful share of what the proxies and MCP servers are automating. Much of what bloats a context window is structural boilerplate strippable by rule, not a judgment. Nobody has measured where that stops being true — logged as open.

Weakness: the token-efficiency claim is asserted, never benchmarked. No agent-facing surface at all (no CLI, no MCP), which is exactly why the research-wiki runner-up is defensible.

avoid-ai-writing run. Verify deferred per hub policy (content-only, no page moves).

[2026-08-03] ingest | Do Context Files Help Coding Agents? (Khatri, arXiv 2607.27250)

Routed from the hub (Telegram). T1 — primary research artifact with full method, a pre-registered manipulation probe, and released code/data/power-analysis. The tier rates the artifact, not the strength of the conclusion: it is a preprint, single-authored by an independent researcher, and by its own power analysis cannot detect anything under 30pp. What it delivers is a bounded null with a mechanism, which is more useful than a bare negative. New pages: context-files-ablation-paper (ScholarlyArticle, source), agent-specific-task-difficulty (DefinedTerm/methodology). Updated: agents-md (its first evidence of effect, after two months of adoption-only sourcing), context-driven-development (premise contested), agent-evals (two design traps + the turn-count portability bug), synthesis, index. Dedup: agents-md, agents-md-spec, context-driven-development, agent-evals, cc-thinking-skills and jetbrains-ponytail-tested all already paged — updated in place, none duplicated. Only one Thing page was created from the paper; the per-agent-difficulty finding earned it because it is reusable methodology, not a fact about this experiment. Gap-relevance: substantially answers the spoke’s oldest open question (Benchmarks) — the neutral, controlled, multi-agent measurement that bullet has asked for since June. Rewritten to say what remains: purpose-built task-specific context untested, no study at the ~120-task scale, and the harness-vs-model tradeoff still untouched. Synthesis: new section “Three independent measurements, three nulls” with a comparison table — cc-thinking-skills (zero robust verdicts), jetbrains-ponytail-tested (works, oversold 3.5×), and this paper (no correctness effect). Three parties, three layers of the structural stack, no outcome improvement in any of them; two found process effects and both authors attributed those to delivery mechanics, not agent capability. That sharpens the standing does-structure-substitute- for-capability question into a testable split: structure changes how an agent works, the model decides whether it succeeds. Contradiction flagged: adoption is not evidence. This spoke documented agents-md through its own site (60k projects, 30+ tools, Linux Foundation) and context-driven-development as a named discipline, all of it about reach rather than effect. Both kept; what does not survive is the inference from one to the other. The one surviving positive result is recorded as narrowly as the paper states it: context cut blind full-suite pytest runs (3.67 -> 2.44 -> 1.67/cell) on the one repository whose file warns the suite takes >20 minutes — an operational saving from a single warning about an unobservable cost, flagged exploratory by the author, and absent on the other repo (which trends the opposite way). Fetch note. The PDF summarizer returned a summary that contradicted the paper’s own abstract — “modest improvements”, “both agents showed performance gains”, Claude 3.5 Sonnet and GPT-4o as the subjects, and rho=0.75 read as a difficulty threshold. All wrong. Extracted the 11-page text with pypdf and worked from the primary throughout; the real agents are Claude Code (sonnet-4-6) and Codex CLI (gpt-5.5), and rho=0.75 is the cross-agent correlation of per-task pass rates. Entity: author Prakhar Khatri deferred — the paper gives a name, an email and “Independent Researcher”, which is not enough evidence for a node under ENTITIES.md. Page on recurrence. Verify deferred per hub policy (content-only). avoid-ai-writing run.

[2026-08-03] ingest | QM — Y Combinator’s multiplayer agent harness

Routed from the hub (Telegram; the repo). T1 — primary artifact: source, licence, threat model and config all inspectable. Everything about how well it works is self-description — no benchmarks, no deployment evidence beyond YC’s own, repo five days old (created 2026-07-29) with 109 open issues. Recorded that candour about limitations is not the absence of limitations; the repo says as much itself (“early, experimental software”). New pages: qm (SoftwareSourceCode, source), agent-scope-isolation (DefinedTerm/architecture). Updated: agent-guardrails (the posture ladder with an effects floor), constraint-evading-behavior (a vendor conceding its own guardrail is bypassable), synthesis, index. Dedup: no QM page existed. agent-memory, agent-orchestration, agent-skills, agentic-coding-harness, cloud-run-sandboxes all already paged — linked, not duplicated. Only one new Thing page: scope isolation earned it as a design problem nobody here had costed; the posture ladder went into agent-guardrails rather than becoming a page of its own. Gap-relevance: opens a genuinely new axis. Nearly every artifact in this corpus is one agent, one principal — coding harnesses run as whoever launched them, and “multi-agent” has meant orchestrated workers of a single user. Once two employees share a deployment, memory, files, keychain view, permissions, skills, crons and sandbox each need an owner. That also argues against the “one markdown file” pole of the standing agent-memory unpriced-range tension: one file can’t hold per-scope views. Synthesis: new section “The agent acquires colleagues.” On the constitution vs containment contradiction, this is the first shipping product to state the containment position as architecture — “the agent and software it runs in a sandbox are not trusted to make authorization decisions” — and then document its own leaks. Command policy “a speed bump against mistakes and injection, not a sandbox boundary”; credential purposes travel “as an instruction to the model” with core not judging whether later commands stay inside them; sandbox credentials plaintext while in use. Recorded as sharpening rather than resolving the tension: containment and prose differ in degree of porosity, not in kind, which puts blast radius back at the centre. The line kept for reuse across every human-in-the-loop page: “An approval means a human accepted the displayed action under the information available at that time, not that the resulting behavior is safe.” Two practices recorded as transferable independent of the product: a 7-day npm dependency cooldown (min-release-age=7, aimed at the yank-within-hours compromise window) — the corpus’s first concrete supply-chain control — and contributions as human-written prose in adrs/, maintainers implementing, with “please do not have AI artificially expand what you’d like to do into a formal proposal.” Small cross-link worth its line: the repo’s CLAUDE.md is nine bytes, the string AGENTS.md — a pointer, not a copy — and the file it points at is mostly process rather than repository facts. Noted beside context-files-ablation-paper, ingested earlier the same day. Entities: publisher is Y Combinator (yc-software); not paged — the evidence here is one repo, and the org’s other appearances in this hub are as an investor, not a builder. Page on recurrence. Verify deferred per hub policy (content-only). avoid-ai-writing run.

[2026-08-03] ingest | claudecode-writer (Women Defining AI) — a Claude Code content workspace

Routed from the hub (Telegram). T3 — a template with no evaluation, no benchmark and no deployment evidence beyond its own illustrative walkthrough. 214★/44 forks is usage evidence, not quality evidence. Stale: created 2025-09-03, last pushed 2025-09-06, read 2026-08-03 — three days of commits and then eleven months of nothing, so it predates the agentskills.io standard and the subagent conventions this spoke tracks. New page: claudecode-writer (SoftwareSourceCode, source). Updated: context-files-ablation-paper (the untested case now has a specimen), renwei-writing (the failure it names, demonstrated by a tool promising the opposite), index. Dedup: autonovel, renwei-writing, writing-a-good-claude-md, claude-md, agent-skills all already paged — linked, not duplicated. No new Thing page: the source is small and its one reusable idea (voice examples as purpose-built context) belongs on the paper that named the gap, not on a page of its own. Gap-relevance: advances the day’s own open question. context-files-ablation-paper, ingested hours earlier, found no correctness effect for generic context files and carved out exactly one untested case — purpose-built, task-specific context, “a fact the agent provably cannot infer.” context/writing-examples.md is that shape: few-shot demonstration rather than instruction, and voice is a genuine knowledge gap, which is the category the paper’s failure triage found absent from coding tasks. So the mechanism behind the null doesn’t obviously transfer. Recorded as a well-posed instance of the question, not an answer — the template ships no evaluation and style match has no gold test. Architecture noted: fan-out repurposing, one researched artifact into N platform-specific transforms by specialist subagents. Contrast autonovel, which also fans out into formats but only after a sequential pipeline with quality gates and retry loops; this has one pass per stage and the human as the only reviewer. Read against its own demo. The README’s showcased LinkedIn output carries every marker of generic LLM social copy — the “still stuck in 2019” hook, a ❌/✅ ladder, one-line paragraphs, “Game changer.”, an engagement-bait question, a hashtag stack — under a promise that “your voice stays authentic.” Recorded on both pages as the 人味儿 failure renwei-writing was written against, arriving from the generation side rather than the editing side. Voice-matching machinery did not prevent it, which is the observation worth keeping; the criticism is of the demonstrated output, not of the idea. Entities: Women Defining AI not paged — evidence here is one repo. Page on recurrence. Verify deferred per hub policy (content-only). avoid-ai-writing run.

[2026-08-04] ingest | agtop (ldegio)

Routed here by the hub (runner-up: platform-ops-wiki). T1 — the project’s own repository, which is the primary artifact for what the tool does, consistent with how this spoke grades headroom and pxpipe. 1 new page: agtop. Updated: synthesis (token-budget corner), index.

It is the corner’s first instrument. The token-budget corner had five levers and all five are interventions — compress (headroom), remove (safe-prompt-pruning), swap modality (pxpipe), route (tokenmining), strip at capture (md-this-page). agtop changes nothing about how an agent runs. It parses Claude Code and Codex JSONL transcripts for spend, tokens and CTX% saturation, correlates OS processes to sessions for CPU and memory, and reports per model and per subagent.

Why that matters more than a sixth lever would: the corner’s claims are quantitative and nearly all self-reported, and this spoke already holds what happens when someone checks one — jetbrains-ponytail-tested took an advertised −54%/−20% to −15.4%/−10.3%. An instrument is what lets a practitioner run that check on their own workload.

Limits recorded on the page: it measures cost, not quality (a session that spent little because the agent gave up early looks good), CTX% makes context-rot‘s quantity visible without making it actionable, and it parses a private transcript format that can change without notice — marked volatile for that reason.

Noted, not acted on: [[claude-code]] resolves nowhere in the corpus. The product is referenced constantly across this spoke and has no entity page, so the two links in the draft were de-linked to plain text rather than inventing a page mid-route. Worth a page of its own on a source that is actually about it.

[2026-08-04] lint | consolidated six dated sections into three thematic ones

Growth edge 4, actioned at the curator’s instruction rather than deferred again. ../QUALITY.md check 3 names dated (added 20xx) sections piling up outside the living thesis as synthesis drift, and this spoke had six of them stacked between Open questions and Contradictions — the most in the corpus.

They were not six findings. Two pairs were one argument each:

  • The agent got a phone and Two arrivals promote a note into a principle were the same claim about derived representations, with the second explicitly ending “see below” pointing at the first. Merged into The surface dictates the representation, which now carries mobilerun, video-use, watch-skill and text-first-agent-design in one argument, with the token-budget corner and agtop as a subsection under it, and the loop-closure point as another.
  • Three independent measurements, three nulls and Verification’s endgame were both about what measurement has found and what it hasn’t. Merged into Structure changes how an agent works, not whether it succeeds — the three-study table, Khatri’s failure triage, and the adversarial hole in automated verification as a subsection.
  • Multi-agent gained a second topology and The agent acquires colleagues both push past one-agent- one-principal, from topology and from principals. Merged into Shared state is the next boundary, with the containment-porosity finding as a subsection.

264 lines → 202. Nothing was dropped: every number, quote and link survives, including the ones that make the spoke look worse (qm‘s SECURITY.md concessions, the 8.6% invisible failures, Mobilerun’s vendor-run benchmark). What went is the accretion — the dates, the “a third arrival the same morning” scaffolding, and the duplicated framing where two sections restated each other.

The rule this leaves behind, recorded in the edge: a new finding extends the thread it belongs to. It does not get a dated section of its own. That is what stopped this spoke’s synthesis being readable from the top, and re-earning it is a full pass.

[2026-08-04] lint | paged claude-code — the hub node the spoke was missing

Curator’s instruction, following the observation logged with the agtop ingest: [[claude-code]] resolved nowhere in the corpus while being named across 84 pages of this spoke. Two links were de-linked to plain text that day rather than inventing a page mid-route; they are restored.

Written from the corpus’s own sources, not from product documentation — which is why the page is short on features and long on how the thing behaves under measurement. That is also the honest division of labour: Anthropic documents what Claude Code does, and this spoke’s value is holding what independent parties found when they tested it.

What it pulls together: claude-md as the vendor-tied sibling of agents-md; claude-agent-sdk as the harness unbundled from the terminal; claude -p headless mode as the primitive under orchestrate-100-agents-claude-code; effort-level as a harness control orthogonal to model choice; and the commercial terms that move (claude-code-weekly-limits-promo, anthropic-agent-sdk-billing-pause).

The section worth having is the measurement one, and it is unflattering to the tool’s own conventions: context-files-ablation-paper found CLAUDE.md-style context injection does not move correctness on it (≤10pp, no-context arm higher on borderline tasks), jetbrains-ponytail-tested took an advertised −54%/−20% to −15.4%/−10.3% running on it, and cc-thinking-skills returned zero robust verdicts from 39 skills inside it. Together they are this spoke’s evidence for the structure-changes-how-not-whether split, and they say the things people bolt onto the harness are worth less than advertised — not that the harness is ineffective. claude-code-best-practices agrees from the practitioner side: “the tool does not matter nearly as much as the person holding it.”

A reflexive note is on the page rather than left implicit: this hub runs on Claude Code and on superpowers, which is a standing reason to read the spoke’s coverage of it with suspicion.

[2026-08-04] quality | staleness queue — 9 pages re-verified, 2 projects superseded

Re-read every past-window page in this spoke. Star counts moved as expected; two findings did not.

get-shit-done was archived 2026-06-26 and is read-only, with development moved to GSD Core (open-gsd/gsd-core). agent-starter-pack is in maintenance mode — critical fixes only, active work moved to agents-cli. Both were ingested in June and both were superseded within weeks. Neither successor is held here. That is the case the freshness convention exists for, and it is the first time the queue has caught a dead artifact rather than a merely dated one.

agentsys‘s claim grew numbers and is still unmeasured. The README now says “Sonnet + agentsys produced more output with higher specificity than raw Opus — at 40% lower cost”, with a table claiming 73–83% cost savings at equal outcome quality. That is this spoke’s #1 growth edge restated by the vendor, not answered — no task set, no trial count, no rubric, no replication. What changed is that it is now specific enough to falsify, which makes it a better target. Edge updated.

Scale corrections worth carrying: gstack 126.3k★/19k forks with 497 open PRs (the maintainer is the bottleneck); openhuman 36k★, still early beta; oh-my-pi 21.8k★, ~80k lines of Rust, 31 tools, and five run modes including ACP; agent-kanban 433★ on an FSL-1.1-ALv2 licence — delayed-open, not open, and the only such licence in the spoke; claude-to-speech 18★, one person’s hook script, recorded as such so the page is not read as evidence of adoption.

jaseci has repositioned: the quick guide now leads with “one language, one compiler, the whole stack. No glue” and two named properties (synechic, topokinetic), presenting a full-stack language whose agent capability is one use case. This spoke filed it as an agent framework. Flagged on the page.

[2026-08-05] ingest | Education Agent Skills (Gareth Manning)

Routed from the hub (runner-up: none — engineering-education-wiki was checked and declined; it owns how software and ML engineers learn, and this is school pedagogy). education-agent-skills — 165 SKILL.md files across 20 domains on the agentskills.io standard, CC BY-SA 4.0, 545★, T2. Created gareth-manning (Person; entity-index returned no match ≥ threshold). Budget: 1 of 8.

Counted from the repository tree, not the README: 165 skills confirmed, 20 domains, largest original-frameworks (17), smallest inclusive-design (3). Ships .claude-plugin/, .codex-plugin/ and .agents/plugins/ manifests, a CI validation workflow, and a hosted MCP server with OAuth.

Two things here are new to the corpus, one is a second sighting.

New: skills that cite their evidence. Frontmatter carries evidence_strength and named evidence_sources — VanLehn (2011), Shute (2008) and similar — putting the provenance of the technique in the machine-readable layer. Folded into the Benchmarks open question as a move on the gap from the other end: it measures nothing, and a citation behind a technique is not evidence for the prompt encoding it, but it makes the quality claim checkable instead of merely asserted. Cheaper to ship than jetbrains-ponytail-tested-style measurement, so possibly more contagious.

New: the first vertical pack aimed past the practitioner. Domain 20 (13 skills) addresses students mid-study-session rather than the teacher.

Second sighting: typed input_schema/output_schema, independently of pm-skills-arsenal — different author, different vertical, both paired with an MCP invocation surface. Two independent arrivals make skill-as-typed-function a property of the standard’s use, not one team’s style.

Caveats on the page: the “evidence-grounded” framing is the author’s own and unaudited; GitHub reads the licence as NOASSERTION while the LICENSE file is CC BY-SA 4.0; the author’s 20-years/27-countries standing is self-reported.

[2026-08-05] ingest | PullMD

Routed from the hub. pullmd — self-hosted URL- and file-to-Markdown service (Aeterna Labs, AGPL-3.0, 365★), T2. Created aeterna-labs (Organization; entity-index no match ≥ threshold). Budget: 1 of 8.

Lands directly in the token-budget corner. md-this-page added strip-at-capture on 2026-08-03 and its page recorded the limit — “no MCP surface, no CLI, no way for a harness to invoke it.” PullMD removes that limit: MCP server, Claude Code skill activating on web-reading requests, OAuth 2.1 for the claude.ai connector. Capture-time reduction moves inside the agent loop for the first time in this corner.

Second thing worth having: the fallback cascade — Readability → Trafilatura → origin-supplied Markdown → headless Chromium via Playwright. An architectural concession that no single extractor works across the web, where md-this-page is Readability alone. Unmeasured, like everything else in this corner; the cascade’s selection quality is precisely what nobody tests.

Routing tension recorded, not hidden. _inbox/firecrawl.md holds a near-twin parked since 2026-06-23 under web-data-extraction, on the reasoning that extraction infrastructure is not agent tooling. The line taken here — Firecrawl is a scale-crawling platform with an agent interface, PullMD leads with agent consumption and fell into a live thread — is thin, and both this page and the park record say so. If a third extraction tool arrives, cluster all three rather than route on thread-adjacency.

[2026-08-05] ingest | Statewright

Routed from the hub. statewright — state-machine guardrail for coding agents (Rust, ~449★), T3. No entity paged: the statewright.ai org has no evidenced footprint beyond the repo; deferred.

Third enforcement shape on the agent-guardrails thread. Blast-radius blocks the dangerous act (agents-never-do-alone); containment sandboxes the agent/its tools (nono); this scopes tool availability by workflow phase (plan=read-only → implement=edit → test=test-cmds), rejecting out-of-phase calls. The novelty is the motive — enforcement aimed at reliability, not safety — which generalizes enforcement-over-instruction from “don’t do harm” to “stay on task.” Destructive-op blocks still apply inside a permissive phase, so it layers on the blast-radius model.

Folded into the Benchmarks open question in synthesis: it reports 2/10 → 10/10 for two local models on a 5-task SWE-bench subset with constraints applied — the cleanest structure-substitutes-for- capability demonstration in the corpus and one of the least measured (self-run, tiny-N, the mirror of cc-thinking-skills‘s honest null, the setup jetbrains-ponytail-tested showed collapses under replication). Kept the one falsifiable boundary: below ~13 GB the models couldn’t retain file content and constraints didn’t help — structure steers a capable-enough model, it doesn’t manufacture capability. Hosted-dependency caveat recorded (requires statewright.ai key; server-side share unclear).

[2026-08-05] ingest | LongHorizon-Harness

Routed from the hub (Telegram). longhorizon-harness — AMAP-ML’s long-horizon harness over Claude Code / Codex / OpenClaw, MIT, T1 (official project repo, per the ladder’s repo rule; the benchmark numbers inside it are first-party and recorded as such). Paged alibaba as the owner Organization — no node existed despite six pages mentioning it; entity budget otherwise unused, AMAP-ML folded into the Alibaba node rather than given one of its own (evidence-only: the repo is its whole footprint here).

The design contribution is where verification sits: the Auditor gates what enters persistent state, so an unverified result never becomes something the next round builds on. That is a third enforcement shape next to statewright‘s phase-scoped tools and agent-guardrails’ blast-radius limits, and it extends the agent-loops-verification thread rather than restating it. Fresh context per Executor round reads as an architectural answer to intrinsic context-rot — if context never grows, the attention budget never erodes.

Gap-relevance: this is the seventh measurement to pass growth edge #2 (the harness-vs-model substitution) without testing it — it holds the backbone fixed at Qwen and varies the harness, the same shape as the six before. The edge stands, better posed: the harness arm now has a price at real N (+28.9 pts over 114 WeaveBench tasks; 108 on OSWorld 2.0), so what is missing is one cell, not the whole design. Synthesis gained the split this makes visible — every independent study in the corpus finds process effects and no outcome effect, every vendor result claims a large outcome gain, and the two groups are also testing generic vs purpose-built structure, so the confound is unresolved either way.

[2026-08-05] ingest | Agentic Awesome Skills (sickn33) + vibe-tools (via Dan Kornas on X)

Two sources routed from the hub minutes apart. Ingested together because they answer the same question from opposite ends, and the synthesis section says so.

agentic-awesome-skills (Collection/SoftwareSourceCode, T3, first-party README read in full — 729 lines): 2,003 SKILL.md playbooks, MIT, ~44.5k★, v15.9.0. The catalog is not the story. At 2,003 skills the index stops fitting, and the README documents its own breakage — Antigravity watching ~/.agents/skills can exhaust context and crash-loop, so the installer refuses to run bare against that target, and manifests cap at 128. The project’s answer is a local read-only MCP the agent queries (search_skills/get_skill/compose_stack), with the agent choosing exact IDs and Core validating structure while explicitly certifying nothing about semantic fit, compatibility or safety to apply. Also recorded: a full install ships critical and authorized-use-only offensive instruction files.

vibe-tools (SoftwareSourceCode, T3): eastlondoner’s Node CLI, MIT, ~4.8k★ — Perplexity research, Gemini whole-codebase context, Stagehand browser control, GitHub/Linear/docs/YouTube integrations. It installs by writing the harness’s instruction file. The arriving source was a promotional X thread by dan-kornas (13 likes, newsletter pitch in the reply); I re-derived every specific from the repository and graded on that, noting the thread as the arrival route rather than the evidence.

New synthesis section, “Progressive disclosure has a ceiling, and a catalog found it”: the cheap-frontmatter premise of agentskills-spec holds per skill and fails in aggregate; the pair of sources is a spectrum with the context budget as its axis — push capability into the context until it stops fitting, then make the agent go fetch it. Neither source measures whether either works.

Entity nodes: sickn33, dan-kornas — both thin, both paged because who curated this is load-bearing for the grade.

[2026-08-05] ingest | SuperClaude Framework

Routed from the hub (runner-up: none). New page superclaude-framework (source, T3 — project README). 30 slash commands, 20 role-persona agents, 7 behavioral modes, 8 MCP servers, pipx-installed as injected configuration into claude-code. MIT, 23.7k★, v4.3.0; v5 is being rebuilt as a TypeScript plugin system.

The useful thing is the comparison, not the feature list. It teaches nearly the same development arc as superpowers and compound-engineering-plugin and differs on who invokes — operator-typed commands, not agent self-invocation — so the spoke now has three packs agreeing on the methodology and disagreeing on the control point. Folded into synthesis alongside the existing invoke-axis paragraph, and added the cross-link from superpowers.

Recorded as the section’s standing hole rather than one entry’s caveat: none of the three has been evaluated. cc-thinking-skills is still the only ablation of a comparable pack, and it found nothing.

[2026-08-05] ingest | Ruflo (rUv / ruvnet)

Routed from the hub (runner-up: none). New page ruflo (source, T3 — first-party README). Agent meta-harness over claude-code: swarm topologies, 100+ agent roles, ~210 MCP tools in parallel, AgentDB/HNSW vector memory, SONA self-learning, zero-trust federation across organizations. MIT, 67.1k★, formerly Claude Flow. Not a duplicate of anything held — nothing in the corpus was paged under either name.

Filed as the stack-everything maximum against entries that each defend one claim (iai-pme memory, nono sandboxing, qm multi-operator, orchestrate-100-agents-claude-code fan-out). One conditional number in the whole README (vector search 1.9×–4.7× over brute force above the crossover). Synthesis now states the pattern directly rather than per-entry: adoption and measurement are uncorrelated here.

Federation flagged as the genuinely new claim — no other entry attempts cross-org agent collaboration.

[2026-08-05] ingest | OPC Skills (ReScienceLab)

Routed from the hub (runner-up: search-marketing-wiki, on the SEO skill only — the spoke’s standing rule files skill packs here). New page opc-skills (source, T3). Apache-2.0, 1.2k★, ~11 skills, 16+ host tools.

Two things it adds. It is the first pack in the corpus whose subject is not software — market research, domain hunting, SEO, logo/banner generation for a one-person company — which means it operates where tests, a compiler and CI do not exist, and nothing in it replaces that verification. And it declares dependencies between skills (domain-hunter needs twitter and reddit), which agentskills-spec does not support and agentic-awesome-skills answers instead with an MCP control plane. Both folded into synthesis; composition now has three documented placements and no argument for any of them.

[2026-08-05] ingest | The Hitchhiker’s Guide to Agentic AI (Roitman, arXiv 2606.24937)

Routed from the hub (runner-ups: engineering-education-wiki, machine-learning-wiki). New page hitchhikers-guide-agentic-ai (source, T1). Book-length practitioner reference, cs.AI, revised 2026-07-27.

First source in this spoke that arrives already assembled rather than as one artifact to be synthesized. Two independent confirmations worth recording: it gives loop-engineering a chapter with named mechanisms (generate-verify-retry, adaptive budget control — the second is a lever nothing here has documented), and it states the in-context/external/episodic/semantic memory taxonomy the spoke had assembled from iai-pme and jcode.

Tension kept rather than resolved: the book treats agent evaluation as teachable while the field ships huge unmeasured packs. Cross-spoke context noted in the page — the substrate/alignment half belongs to machine-learning-wiki and llm-inference-wiki, and the artifact is also a curriculum of the kind engineering-education-wiki studies. Routed here on the second half, which is this spoke’s domain.

Not new evidence: a synthesis is only as good as its references, and the page says so.

[2026-08-06] ingest | Claude Code Development Kit — the doctrine shipped as defaults

Routed from the hub (Telegram, curator); no competing spoke, this is squarely agent tooling.

New page claude-code-development-kit (T1, first-party repo). Peter Krueck, MIT, 1.4k★. Four docs/ai-context/ files kept in step by /update-docs, tiered /prime (~4–6k tokens at the light default), /review-work fanning out Bug Hunter / Rules Auditor / Architect subagents, /second-opinion escalating to Codex or Gemini CLI, plus secret-scanner and deny-list hooks.

The reason it is worth a page rather than a line: its foundation is the exact mechanism context-files-ablation-paper ablated to a null across 288 gold-test runs. The kit reports no evaluation, so it adds nothing to that. But all of its own claims are process claims — less re-derivation, smaller loaded floor, cleaner merges — and process effects are precisely what the measured studies did find. So it is not in conflict with the corpus’s strongest measurement; it is selling the half that survived. Folded into synthesis under the structure-vs-capability table, with a new edge: nobody has priced the structural layer against the burn it removes, and /update-docs, /review-work and /second-opinion each cost a run.

Two tensions recorded rather than resolved. claude-md‘s discipline is hand-authored, never auto-generated; /update-docs is machine maintenance, so the kit joins the auto-generation pole next to openwiki and autowiki-factory — with the wrinkle that its files are opt-in behind /prime, which exempts them from the instruction-ceiling argument but not the low-signal-bloat one. And the review-on-stop hook nudges across three stops before a final commit, which by this spoke’s own agent-guardrails and constraint-evading-behavior pages is a prompt rather than a boundary; the deny list and secret scanner are the real ones.

Also classified: it is not a harness — no loop, no runtime. A configuration layer over someone else’s, and the packaged form of governed-context-claude-code.

No entity node for Peter Krueck. The source gives a name and a LinkedIn link and nothing else; ../ENTITIES.md is evidence-only and the page would have been a name. Same call as staskh earlier today.

[2026-08-06] ingest | Model or Harness? An Interaction-Centric Taxonomy for Localizing Agent Failures (hub-routed, Telegram, URL-only, T1)

Raj, Gupta, Mahmoud, Dumitru, Yi, Sabharwal & He (Scale AI), arXiv:2607.28802v1, 2026-07-30. Created source summary model-or-harness-taxonomy (ScholarlyArticle, url-only, T1 — frozen protocol, published agreement statistics, stated limitations; preprint, 40 examples annotated by the taxonomy’s own authors). Created concept page agent-failure-localization: the repair-assignment problem and the edge-plus-fault-side scheme that answers it, with the root-cause rule (label the earliest failure from which execution does not recover) and the note that 36-of-41 model-side is an artifact of the attribution rule, not a measurement.

Threads updated. agent-evals gains “A score does not tell you what to fix” — an eval answers did it regress, never which component to repair; localization presupposes the trace, so the page’s tracing argument arrives a second time from the diagnostic side. agentic-coding-harness gains “When the harness is the thing that broke” — agent = model + harness splits the blame too, and the taxonomy’s uncomfortable result for this spoke’s thesis is that blame still defaults to the model.

Synthesis: growth edge #2 (the harness-vs-model tradeoff) gets its first entry that is not an eighth miss — the paper is upstream of the measurement the edge wants, supplying the classification a frequency study would have to count with. Edge restated to ask for both the controlled comparison and a frequency study. The “does structure substitute for capability” open question gains a third bound: the five non-model failure modes are the cleanest statement yet of where structure is not substitutable.

Entities: scale-ai (Organization/Corporation, sourceOrganization) and harsh-raj (Person, lead author) — both thin, evidence is the one paper. Budget: 2 of 8. Noted on scale-ai that an evaluation-company publishing a failure-attribution scheme validated on its own annotations is adjacent to its commercial interest, which is why it does not satisfy growth edge #3.

[2026-08-06] ingest | Scaffold Effects on GAIA: A Controlled Comparison (research pass, T1)

Starace, arXiv:2606.08529 (2026-06-07), hunted via the hub Research Pass against ## Most wanted #1. This is the design the spoke’s oldest edge specified, and it closes it: 5 models × 3 scaffolds × 139 GAIA questions × 3 attempts, pre-registered, 5,907 completed runs — both factors varied in one experiment, where the previous seven sources each held one fixed.

Created scaffold-effects-gaia (ScholarlyArticle, url-only, T1) and jason-starace (Person, thin, no affiliation stated). Entity budget 1 of 8.

The finding, in the form the spoke needed it: scaffold choice moves a single model by up to 23 points, but never across a capability tier — Haiku’s best configuration (0.459 L1) stays below Sonnet’s worst (0.660). It does carry one step: Sonnet + Planner-Actor-Rater beats Opus + planner-executor on both levels, which is agentsys‘s README claim confirmed under control for the first time since June, and simultaneously bounded. Two corollaries recorded: the best scaffold is model-specific (Opus tops L1 on plain ReAct; the multi-agent scaffold hurts it, and its advantage never left the Anthropic family), and every single-scaffold benchmark number in this corpus is a scaffold-conditional estimate.

Weaknesses recorded, not smoothed: the scaffold arms vary their tool surface alongside loop structure, so the effect is scaffold-plus-tools; GAIA validation answers are public and the author says L1 may partly reflect memorization; 314 records lost to provider errors; cost is log-derived not billed. Single author, single non-coding benchmark.

Synthesis: the open question “does structure really substitute for capability, and how far?” is marked answered with the history and the earlier bounds kept below it (record-don’t-overwrite). Growth edge #2 retired as CLOSED and replaced, ranked lower, by the same design on a coding benchmark.

[2026-08-06] ingest | diagram-design (hub-routed, Telegram, URL-only, T1)

cathryn-lavery‘s Claude Code skill for editorial diagrams (MIT, ~3k★/220 forks, 22 commits). Created source summary diagram-design (SoftwareSourceCode, url-only, T1 — official repo; every quality claim is first-party and nothing is measured against a generic-diagram baseline) and the author node cathryn-lavery (Person, thin — BestSelf.co founder; a product-design practice, not an engineering one). No new concept page: the substance lands on reasoning-scaffolds, which gains a paragraph — this is the output-shape category in visual form, and the first one whose form rules are checked by a linter rather than by the model’s own pre-send inspection (i-have-adhd) or a reader’s eye. Second point of interest: a one-time brand-capture step (read the user’s website, extract colors + fonts, reuse forever) — claude-md/agents-md durable context applied to visual identity, with the state sourced from outside the repo. Folded into synthesis.md in two places: the output-shape/restraint passage, and the vertical-generalization list, where the designpowers pairing gives one design vertical two opposite structural bets (10-agent pipeline vs one skill over 34 progressively-loaded reference docs). Also noted: self-contained HTML+SVG output (no build/JS/CDN) as text-first-agent-design‘s instinct pointed at the deliverable, rhyming with beautify-github-readme‘s Markdown/SVG split. Cross-spoke context recorded on the page: design-system substance is adjacent to ui-frameworks-wiki’s design-system, which stays the owner of design systems as a building concern.

[2026-08-07] ingest | Claw-SWE-Bench (Zheng et al., arXiv 2606.12344) (via research pass)

T1 — arXiv preprint, 2026-06-10. Closes the coding half of growth edge #2, the successor the 2026-08-06 pass wrote when scaffold-effects-gaia closed the general form: “a T1/T2 crossed model × harness comparison on SWE-bench-class tasks.”

350 issue-resolution instances, 43 repos, 8 languages. Prompt template, Docker image, repo state, 3600s timeout and the SWE-bench evaluator are all held fixed, so the deltas are harness or model and nothing else. Harness spread 12.5 pp (GLM 5.1) / 27.4 pp (Qwen 3.6-flash); model spread 29.4 pp across 9 models. Authors: “harness choice is a first-order factor… large enough to reorder leaderboard conclusions if the harness is not specified.”

The finding folded into the synthesis is the interaction: harness spread roughly doubles as the model weakens, and the weakest harness (generic) loses 24.5 pp across that step against openclaw’s 7.4. So scaffolding substitutes for capability, and is worth most where capability is least — which extends GAIA’s “one tier, not two” rather than repeating it.

Recorded limits: two grids rather than a full factorial (only 2 of 9 models meet all 5 harnesses); no frontier model in the harness sweep, so the top of the range is the untested cell — filed as the replacement edge. One ordering artifact in the paper’s model table (DeepSeek-V4 Flash listed below MiniMax 2.7 despite scoring higher); every Pass@1 checks out against its resolved count over 350.

Rejected in the same hunt: CodeScout (arXiv 2603.05744). Two fetches of the same paper returned irreconcilable model sets — a search summary said GPT-5-mini / DeepSeek R1 / Qwen3 Coder 480B, a PDF read said Claude 3.5 Sonnet / GPT-4o / Claude 3 Opus with a suspiciously uniform “+8pp for all three” and approximate figures. Not ingested: the numbers could not be pinned down, and it is a problem-statement-augmentation study rather than a harness comparison. Inside the Scaffold (2604.03515) also passed over — a 13-agent source-code taxonomy with no benchmark results. No entity nodes created (Zheng et al. — thin one-off authors; no recurrence yet).

[2026-08-07] ingest | Stanford is running 37,000 AI agents as a virtual biotech (VentureBeat)

Routed from the hub (Telegram). VentureBeat’s write-up of James Zou‘s VB Transform 2026 talk on virtual-biotech — T3: trade press relaying a first-party conference talk, tiered by what it rests on. Every load-bearing number is the speaker’s own and the linked bioRxiv preprint (2026.02.23.707551) is not read.

New pages: stanford-virtual-biotech-37000-agents (source summary), virtual-biotech (the system), paperclip (its context layer), agent-environment-design (the environments-not-workflows principle). Updated agent-orchestration — Virtual Biotech is now the largest instance in the wiki by two orders of magnitude, and a different shape: agents differentiated by role and data source, with debate between them as the claimed mechanism rather than coverage or a shorter tail.

Synthesis gained a section (“At 37,000 agents the unit of design changes”) and one contradiction bullet — specify more vs specify less, since the spoke’s spec-driven thread and Zou’s “stop telling agents how to work” cannot both be the general rule. Also recorded: wrapping a legacy database in MCP leaves the interface mismatch untouched, which qualifies how this wiki has treated MCP.

WebFetch was blocked (HTTP 429); the text came from the firecrawl fallback.

Entities (6 created, 0 linked, budget not hit): james-zou, stanford-university, merck, venturebeat, ben-dickson, vb-transform. entity-index returned no match for any of them; the “Stanford University” hits were other universities matching on the common word.

Cross-spoke context noted on the source page rather than paged: the drug-discovery substance (nanobodies, CD276 ADC, FDA breakthrough designation) has no owner in this hub, the “agent school” supervised fine-tuning is machine-learning-wiki’s subject, and the question of what an autonomously designed therapeutic must clear is ai-governance-wiki’s.

[2026-08-07] ingest | OpenEdit (veedstudio/open-edit)

Routed from the hub (Telegram), second source of the evening. VEED‘s Apache-2.0 agent skill that turns a coding agent into a video editor — T1 (official project repo per the QUALITY.md ladder), promotional and unmeasured.

New pages: open-edit (source summary), veed (Organization). Updated video-use — the two are the same job answered differently, so each now points at the other — and text-first-agent-design, which gains the neighbouring move: OpenEdit has the agent author captions in HTML/CSS, choosing the notation the model knows rather than the description the platform maintains. Same instinct as paperclip, routed an hour earlier.

Synthesis gained “Two answers on one task, four days apart” under The surface dictates the representation. The two portable findings: transcription providers are abstracted behind one file while the per-word-timing precondition is a hard refusal (a mechanical gate on an input, rare in this corpus), and the vendor shape is an application company publishing the agent-native replacement for its own subscription, funnel moved to transcription.

Recorded as claimed, not shown: “up to 2.2x faster than Chrome-driven renderers,” which the README itself calls preliminary and not reproducible outside VEED. Also noted: Apple Silicon + macOS Tahoe 26.0 only, and V1 scope is captions with motion graphics/charts/brandbook styling admitted to be rough.

Entities: 1 created (veed), 0 linked. Fal, Seedance 2.0 and Figma stayed plain mentions — composed services, not agents of this source.

Tier discrepancy for the next Quality Cycle: video-use carries tier: T2 for the same class of source (a project’s own README). The ladder’s “official project repo stays T1” rule and the curator’s 2026-08-05 call both say T1. Left alone here rather than changed mid-ingest.

[2026-08-08] ingest | Harness-Bench (arXiv 2605.27922) — research pass

Via the hub Quality Cycle’s research pass, against this spoke’s #2 corpus-wide edge — harness spread at the frontier, written 2026-08-07 as the successor to the coding-benchmark edge. T1, and it closes the edge outright.

harness-bench: 8 model backends × 6 harnesses (+ Codex), 106 tasks, 5,194 trajectories, shared environments/budgets/protocol while preserving each harness’s native execution. Frontier models are in the grid (claude-opus-4.6, gpt-5.4, gemini-3.1-pro-preview), which is exactly the cell claw-swe-bench could not test.

The finding: “Stronger model backends tend to achieve higher mean scores while exhibiting lower cross-harness variance.” Harness sensitivity falls as capability rises — the trend Claw-SWE-Bench saw between two mid-tier models continues to the top. It does not reach zero: 23.8 pp separates NanoBot (76.2%) from openclaw (52.4%).

Folded into the standing contradiction, which had said “watch the harness-substitutes-for-model claim against future neutral benchmarks” — three have now arrived and agree, so the line is rewritten as a finding rather than a watch. The authors’ corollary is kept: report capability at the model-harness configuration level, since a score without a named harness says little.

Worth sitting with: openclaw — the most-starred harness in this corpus and the centre of gravity for a dozen of its pages — comes last of six. Adoption and execution visibly disagree here.

Successor edge written: the benchmark scores whole harnesses, so it cannot attribute the spread to a mechanism; this spoke documents mechanisms. Needs a T1/T2 one-mechanism-at-a-time ablation on a fixed model.

Entities: 0 created — twelve authors, no recurrence, abstract-and-tables knowledge only; same call as the claw-swe-bench ingest made on Zheng et al.

[2026-08-08] ingest | DDR-Bench — one mechanism at a time, on a fixed model

Research pass, hub ## Most wanted edge #8. ddr-bench new (T1, arXiv 2602.02039, Liu/Yu/Orini/ Du/He).

The benchmark itself (Deep Data Research over databases) is not why it is here. Its Section 5.2 ablations are: reasoning budget, memory mechanisms, and reactive-vs-proactive, each varied independently on one fixed model under a minimal ReAct scaffold. That is the design the edge asked for, and it is the complement to what the spoke already had — scaffold-effects-gaia crosses models with whole scaffolds, harness-bench scores whole harnesses at scale, and neither can attribute a point of the spread to a component.

Direction reported: memory and reasoning modifications produce inconsistent results rather than clear improvements.

Recorded and worth re-reading later: the paper’s stated reason for a minimal scaffold is that harness machinery is a confound when measuring a model. This wiki documents that machinery as the product. Both hold, but the tension is noted on the page rather than smoothed over.

Correction made during the ingest. A search summary attributed to this paper a framework comparison (ReAct vs Plan-and-Execute vs CoALA vs AutoGen, with complex frameworks degrading against ReAct). The paper does not contain it. Checked against the HTML before writing; that claim is not recorded here.

Not held: Tables 3–5 did not extract from PDF or HTML, so there are no per-mechanism deltas. Edge marked partly closed, still open for the numbers.

[2026-08-08] lint | DDR-Bench — correcting my own correction, with the table this time

The ddr-bench entry above records that a search summary claimed the paper compares ReAct against Plan-and-Execute, CoALA and AutoGen, that I checked the HTML, and that the paper “does not contain it.”

That was wrong, and the search summary was right. The comparison is Table A1, in the appendix, which neither the HTML nor the PDF summarizer surfaced. Extracting the PDF locally with pypdf found it immediately.

The numbers, ReAct baseline against each single addition, three datasets × three models: 2 of 27 comparisons beat plain ReAct, both +Plan on 10-K. Memory never wins anywhere. Multi-agent is worst or near-worst in every row and takes MIMIC/Qwen3-4B from 16.67 to 4.44. The paper’s own words: “complex agents mostly degrade performance relative to the ReAct baseline” and “memory modules often destabilise performance”, explained as scaffolding disturbing model confidence into “premature self-termination or over-/under-thinking.”

Page updated with the full table. Edge #2’s successor is no longer “still open for the numbers” — the numbers are here, and they point away from what this spoke has assumed. What remains open is a coding workload, since DDR-Bench is database analysis.

Method note worth keeping: a web-extraction failure is not evidence of absence. Twice today a paper’s real content sat in a PDF that the fetch tool rendered as compressed binary. Extract locally before recording that something is not in a source.

[2026-08-09] ingest | SWE-bench, τ-bench, WebArena — the benchmarks the spoke argued about (via research pass)

Coverage edge 7, mostly closed: the three benchmark papers, all T1 — Jimenez et al. (ICLR 2024), Yao et al. (2024), Zhou et al. (CMU, 2023). BrowserGym, also named by the edge, is still absent.

New pages: swe-bench, tau-bench, webarena.

Why this mattered more than page count. SWE-bench appeared in seven pages here as a bare number. Reading the paper puts those numbers in their place: at publication the best model resolved 1.96% of 2,294 tasks. Nearly everything scored since then was bought by the scaffolding — retrieval, edit tools, test feedback — which is the spoke’s own subject. A benchmark the corpus treated as a model ranking is better read as evidence for the harness thesis.

τ-bench supplies the metric the spoke was missing. pass^k — succeed on the same task in all k independent trials — is a reliability measure, and GPT-4o’s pass^8 in retail is under 25%. Single-run comparisons between harnesses cannot answer the question shipping-without-human-verification asks; this can.

WebArena covers the third surface: real self-hosted web apps, functional-correctness grading, and a 14.41% agent score against 78.24% for humans in 2023. Stale in absolute terms, and the right citation for the browser-agent claims in ../web-browsers-wiki, where vendors publish their own numbers on their own setups.

Successor edge recorded: all three papers are from 2023–24 while the scores quoted here are current, so contamination/saturation on SWE-bench and an independent re-run are what the corpus now lacks.

Entities: 0 created — Princeton and CMU deferred; no author pages on a single paper each.

[2026-08-09] ingest | Auto mode as the Claude Code default — the spoke’s first permission source

Arrived via Telegram. simon-willison, 2026-08-08. T2 — independent commentary, transparent about which claims are the vendor’s, wrapped around figures that are all Anthropic’s.

New pages: claude-code-auto-mode (source) and agent-permission-model (mechanism). claude-code updated with the change and re-dated. simon-willison linked cross-wiki to llm-providers-wiki. Trajectory Labs named once and deferred, per ../ENTITIES.md.

What it establishes. Auto mode becomes the default for new sessions on Pro, Max and Team plans from 2026-08-14: the agent approves its own actions rather than stopping for confirmation. Anthropic reports it blocking 89% of harmful actions against 13.6% caught by the human reviewers it replaces (n=1,053 paid developers), and a commissioned Trajectory Labs evaluation in which none of 720 injection attempts succeeded against Fable 5, Opus 5 or Sonnet 5 under auto mode.

Why it changed the synthesis rather than adding to it. This is the first source here about what a harness forbids rather than what it enables, and the 13.6% figure indicts a design most of the corpus’s tools share. Confirmation fatigue means an approval prompt degrades in proportion to how much the agent is used — so the spoke’s own enthusiasm for longer, wider agent runs (run-claude-code-agents-24-hours, orchestrate-100-agents-claude-code) was quietly disarming the safety story those tools ship with. Folded in as “Permission is the dial that runs the other way.”

Recorded against it. Every figure is vendor-generated, including the third-party test the vendor commissioned. A 720-of-720 result describes the attack set, not the attack surface. Willison accepts the design — “I absolutely buy that auto mode is a better solution than asking humans to constantly approve actions” — and wants “more independent confirmation of this”, naming the vector the suite plausibly misses: a malicious package whose instructions read as legitimate work rather than as an attack. His standing prediction of a coding-agent security disaster in 2026 is unretracted.

[2026-08-10] ingest | MimiClaw — an agent harness in C on a $5 microcontroller

Routed here by the hub (runner-up: embedded-iot-wiki, which owns esp32, microcontroller and espressif — the substrate half is cross-linked there, not duplicated). Source: https://github.com/memovai/mimiclaw, T1, MIT, 5,608★/829 forks/114 open issues, repository created 2026-02-04, read 2026-08-10.

Pages: mimiclaw. openclaw gained a fourth derivative shape; synthesis gained “The substrate floor”.

Why it belongs here rather than in the hardware spoke. The subject is an agent harness; the ESP32 is where it runs. It credits openclaw and Nanobot as the architectures it reimplements, and the spoke already documents that family in depth. The hardware question — what an MCU can host — is real and is the runner-up spoke’s.

The finding. It ships four of the six parts of the openclaw-hermes-control-layer anatomy: runtime, gateway, memory, tools. No identity, no policy, no approval prompt. Those two omissions are exactly what nemoclaw and microsoft-scout were built to add to OpenClaw, so the anatomy’s claim that they are the control layer and not the working layer now has its demonstration at the bottom of the range.

Autonomy without a gate, and why it is survivable. A 30-minute heartbeat re-prompts the agent from HEARTBEAT.md, and cron_add lets the model schedule its own wake-ups across reboots. Against claude-code-auto-mode‘s 13.6% figure, there is no control here to degrade. What limits the damage is that the five tools are web search, a clock and three cron calls — containment by capability poverty, a third mechanism beside agent-guardrails sandboxing and the approval prompt. It costs nothing and it ends with the sixth tool.

Correction recorded against the marketing. The README headline says “AI assistant on a $5 chip”; the repository’s own GitHub description says “Harness on a $5 chip”, and the second is accurate. The board asked for is 16 MB flash / 8 MB PSRAM at ~$10, and every turn is a metered API call to Anthropic or OpenAI with the key on the board (model-or-harness-taxonomy).

Flagged, not editorialised. API key, Telegram token and WiFi credentials sit in a build-time C header or NVS flash, on a board with OTA firmware update and an unauthenticated WebSocket gateway on port 18789. The docs do not discuss authenticating it.

Entities: memovai and the X handle @ssslvky are named once each with no biography evidenced; deferred per ../ENTITIES.md.

[2026-08-10] ingest | Agent SDK Workshop — the layer stack, stated as an order

Routed from the hub (Telegram). github.com/anthropics/agent-sdk-workshop — Apache 2.0, Python, ~56★, one commit. Anthropic’s own hands-on course for the claude-agent-sdk. T1 as a first-party artifact; authoritative about what the SDK offers and about how its vendor thinks it should be learned, evidence of nothing about whether agents built this way work.

Dedup: claude-agent-sdk already existed and was refreshed in place with a “How Anthropic teaches it” section rather than duplicated. New page: agent-sdk-workshop.

The finding. The workshop takes one agent through four config booleans — system prompt → ENABLE_TOOLS → ENABLE_SUBAGENTS → ENABLE_MEMORY. The switches are independent, so the order is a judgment, not a constraint: capability first, coordination second, persistence last. This spoke built the same layer list bottom-up from artifacts that each argued for one layer; this is the first time it arrives as a dependency chain from the party that ships the loop. Recorded in synthesis.

The caveat, and one exception. Every stage is presented as an improvement and nothing is measured, which is the shape cc-thinking-skills, context-files-ablation-paper and jetbrains-ponytail-tested have taught the corpus to discount. The exception is stage 1: tools is the layer none of those studies ablated, and the one with a plausible mechanism for a real gain. Nobody has measured it.

Also noted: four of the six breakout scenarios (chief-of-staff, customer-support, sre-agent, account-intelligence) are operations roles rather than coding, against a corpus that is almost all coding harnesses. sre-agent is the seam with ../platform-ops-wiki, as a teaching fixture only. All tools run on mock local data.

[2026-08-10] ingest | Turing Post’s 13 frameworks — the layer under the harness, counted

Routed from the hub (Telegram). turingpost.com/p/frameworks-sdks — Alyona Vert, 2026-08-09. T3: a newsletter survey, secondary, unmeasured, no inclusion criteria stated.

New pages: turingpost-13-frameworks (source), agent-framework (the layer), turing-post (publisher; entity-index returned nothing ≥ threshold, so a new node).

Dedup: adk and langchain already existed and are linked, not rewritten. The other eleven frameworks are named in the source page’s table and not given stub pages — this is a census, and the awesome-osint-list precedent applies: page the census, not every row.

What it opens. This spoke’s corpus is things you run — harnesses, skillpacks, meta-harnesses. This is the layer you build with, and it had never been paged as a class. Three findings went to synthesis: the layer is Python (12 of 13; Mastra alone isn’t), it has begun specializing by use case (voice, RAG, simulation, enterprise), and Anthropic is absent from a list holding OpenAI, Google, Microsoft and AWS-via-Strands. That last one is recorded as an observation about the article’s selection — with no stated inclusion rule there is no way to separate an omission from a judgment, and the page says so rather than guessing.

A vocabulary collision worth having caught. The article’s ladder (model → API → SDK → framework) sorts by how much arrives pre-built. Anthropic’s, already on claude-agent-sdk, sorts by who runs the loop and where. Both call the middle rung an SDK and they are not close.

Same hole, one layer down. Nothing measures a framework against building on the API directly. The survey grades ergonomics, community size and one star count. Up a layer, three parties ran controls and found process effects without correctness effects; down here nobody has tried.

[2026-08-10] ingest | LLM Engineer Toolkit — a second census, and it disagrees with the first

Routed from the hub (Telegram). github.com/KalyanKS-NLP/llm-engineer-toolkit — Apache-2.0, 10.7k★, 150+ libraries in 15 categories. T3: per-entry descriptions and a maintained category scheme, but no inclusion criteria, no dates, no per-row licence or maintenance signal — same grade and reason as awesome-agent-evolution.

New pages: llm-engineer-toolkit (source), kalyan-ks (thin Person, on the astrosp rationale). agent-framework and turingpost-13-frameworks both updated in place.

Why it routed here against machine-learning-wiki and llm-inference-wiki: Agents is the largest category (23), and agents + application development + prompts + structured outputs is about a third of the catalog. The training/fine-tuning (16), data (12), inference+serving (9), RAG (11) and safety (9) facets are recorded as cross-spoke context on the source page rather than split out.

The finding: the category has no agreed membership. Read against turingpost-13-frameworks from one day earlier — 27 agent libraries here against 13 there, 7 on both. The misses are patterned: Turing Post has the vendor SDKs (adk, Microsoft Agent Framework, Strands) and the non-Python entries (Mastra, LiveKit) that this list lacks; this list has a community stratum (AutoGen, Swarms, Composio, Browser Use, AgentOps, Langroid) Turing Post lacks. One census is shaped like the vendor landscape, the other like the Python OSS community, and neither says so.

Anthropic absent, twice. Checked deliberately, because yesterday’s page recorded the absence from Turing Post and declined to explain it. There is no Anthropic agent library here either — “Anthropic” occurs once in 150+ entries, inside traceAI’s description of what it instruments. Second data point, still not an explanation.

A correction to how this spoke states its own complaint. Evaluation is the catalog’s second-largest category — 15 libraries. “Nobody evaluates agent tooling” is too loose. The instruments exist in quantity; what the corpus has never found is anyone using them to publish a result about the tools paged here. Reworded in synthesis.

2026-08-11 — ingest: Confucius Code Agent (research pass, via hub quality cycle)

confucius-code-agent (T1, Wong et al., Meta + Harvard, arXiv 2512.10398v5). Closes the coding half of the mechanism-attribution edge — the one ddr-bench left open because its ablation ran on deep-data-research tasks, not code.

Held: the four-mechanism scaffold (context management, note-taking agent, extensions, meta-agent), 54.3% Resolve@1 on full SWE-Bench-Pro with Claude 4.5 Opus, and Table 2’s ablation on a 100-example subset — context management +6.6 pp on Claude 4 Sonnet (42.0 → 48.6) against +0.6 pp on Claude 4.5 Sonnet (51.0 → 51.6); tool sophistication +7.0 pp (44.0 → 51.0).

The finding is about stability, not size. A mechanism worth nearly seven points on one model is worth half a point on its successor. That reframes DDR-Bench’s inconsistent results rather than contradicting it: if per-mechanism value collapses as the base model improves, an ablation on a single model will read as inconsistent from outside. Two labs, two workloads, same conclusion — harness gains do not transfer across models, so a reported gain without its model is not information.

Limits recorded on the page: 100-example subset, single runs, no variance, only two of four mechanisms varied (note-taking and meta-agent never removed), and the lab is evaluating its own scaffold. Successor edge written — an ablation with repeated runs and variance, covering persistent memory.

[2026-08-12] ingest | WebMCP — the agent→page slot, and a spec arguing against MCP

Routed here from the hub after a ../webperf-wiki re-read found lighthouse auditing pages for WebMCP conformance while no page in any of the 35 spokes said what WebMCP is. It was hub Quick win 13 for a few hours.

webmcp (T1, the W3C Web Machine Learning Community Group explainer, with Chrome’s own docs as a second T1 for shipping detail). A page exposes its JavaScript functions and <form> elements as tools with descriptions and JSON schemas, and an in-browser agent calls them: document.modelContext.registerTool({name, description, inputSchema, execute}, {signal, exposedTo}). getTools(), executeTool() and a toolchange event are named but still TODO. A declarative form synthesizes tools from annotated <form>s; both exist because “some of the web’s functionality is only possible with JavaScript.”

The problem statement is the find. WebMCP’s case against backend integrations names MCP and OpenAPI and calls the cost “UI Disintermediation & Context Loss” — the server-side approach forces a developer to “replicate the user’s state, active context, and authentication credentials on a separate server.” This spoke has held that objection before, but only from critics. Here it is the opening argument of a specification written inside the same ecosystem, which still “derives direct inspiration and shares a common vocabulary with MCP.”

It slots into agentic-resource-discovery‘s stack and then dents it. The stack was MCP (agent→tool), A2A (agent→agent), Agent Skills, AGENTS.md, ARD (discovery). WebMCP is agent→page — and a capability living inside a page is one an ai-catalog.json entry cannot point at, so ARD’s index has a blind spot by construction. Recorded on both pages.

Third governance shape, and the pattern is now properly broken. A2A, AGENTS.md and ARD all ran vendor → neutral foundation → default. pilot-protocol inverted that by being a company operating its own network. WebMCP has no single vendor to invert: Microsoft and Google are co-authors from the first commit (13 August 2025 — Brandon Walderman, Leo Lee, Andrew Nolan; David Bokan, Khushal Sagar, Hannah Van Opstal), in a W3C CG rather than a foundation built around the artifact. Argued in synthesis.md that the three shapes fail differently, which is what makes the distinction worth keeping.

Status recorded honestly: unsettled. 124 commits against 108 open issues, no version number, Chrome 149 origin trial plus a local flag. Neither Apple nor Mozilla appears anywhere in what was read — a gap named on the page rather than glossed, since a proposal adding an agent-facing API surface to every page on the web needs more than one engine.

Security recorded as incomplete, not adequate. Origin isolation by default, Permissions Policy allow="tools" for cross-origin iframes with NotAllowedError on refusal, an exposedTo opt-in array — and the explainer defers the rest to a spec section. A page volunteering executable, natural-language- described entry points is a new attack surface, prompt injection reaching a registered tool being the obvious one, and the source does not work that through. Stated as a limit on what this corpus can claim.

Entities: microsoft and google linked; the six named authors were not paged — authorship alone is not the evidence ../ENTITIES.md asks for. Cross-spoke facets recorded to webperf (lighthouse — the audit shipped ahead of the standard), search-marketing (llms-txt — the other bet on machine-usability), and web-browsers (a CG proposal behind one vendor’s origin trial).

Related pages

Links to