Skip to content
Skip to content
Weekly synthesis2026-W46

The Agent Stack Acquired Dependencies, but Not an Acceptance Authority

7 min read

What changed our view

This week extended the context-control thesis into a dependency-promotion thesis: guidance, skills, memory, browser tools, review agents, and approval state can now be installed and versioned, but no one of them should decide whether its own work is authorized, complete, or acceptable. Last week identified context as a control surface whose source, freshness, scope, and authority must be known before it influences action. This week made the next operation visible: after a dependency is admitted, run it on a bounded task, preserve a control arm and negative case, and promote it only if an application-owned postcondition and accountable reviewer show useful lift.

The concrete example is a React dialog fix. Modern Web Guidance can supply current browser practice, Chrome DevTools MCP can inspect the page, SkillEvaluator can compare with and without the skill, and Plannotator can organize human feedback. The application still owns the exact checkout, user, allowed files and effects, accessibility and browser checks, accepted result, reviewer decision, and rollback.

  1. 01Build a thin promotion record, not a governance platform.
  2. 02Compile effect policy before retrieval where possible.
  3. 03Keep completion, completeness, and acceptance distinct.
Jump to section

Scout Weekly — November 9–15, 2026

Evidence

The week began at the tool boundary. Monday's browser evidence separated a successful command from the intended session, principal, and application state; the official MCP server advisory and destructive-tool research kept approval and filesystem confinement as composed properties. Tuesday's Astryx evidence moved design-system knowledge into a project-pinned CLI, while its own local-MCP RFC showed why hosted current knowledge can still describe the wrong installed package.

Wednesday and Thursday turned expert procedure into a dependency lifecycle. Modern Web Guidance 1.0 packaged cross-browser guidance with vendor-run guided-versus-unguided evaluations. NVIDIA's SkillSpector and SkillEvaluator separated exact-byte admission and coverage from paired task lift. ReTrace, ARE-bench, and falsification-gated memory work separately made stable procedure compilation, material workspace state, and memory promotion measurable. Those results were not reproduced, but they reinforced one operation: discover, admit, evaluate, then promote narrowly.

Friday and Saturday moved completion and review inside the same contract. The Codex Security release stream added durable lifecycle and imported evidence, while issue #2446 reported a scan finalizing after workers reached a usage limit. Direct ExperiencedDevs, AskProgrammers, and developersIndia discussions described code generation as cheap while review, system understanding, protected tests, rollout, rollback, and repairability remained scarce. These discussions indicate reported needs, not prevalence.

Sunday supplied the architectural join. CapLite derives write policy from typed tool schemas and the user's request before tool output can introduce new intent. CoReMem charges retained coding memory for its write and read cost and measures its help on the next task. Together they strengthen the weekly view: policy, memory, procedure, and review should be promoted by externally measurable task value, not by self-description or installation success.

Counter-evidence

There is real progress inside the dependencies themselves. Modern Web Guidance publishes paired evaluations; Codex Security preserves more lifecycle and imported evidence; SkillEvaluator supplies a control arm; MCP maintainers published a more predictable release cycle; browser tooling and package registries make representative trials cheap. A team should not rebuild those mechanisms from scratch.

The limitation is narrower: vendor-run evals, package reach, protocol conformance, a clean tool result, or a completed scan may each be valid evidence without being the final application verdict. Scout did not reproduce the research results or vendor benchmarks. Two npm pages were blocked during deterministic hydration, so package metadata remains a verification-limited distribution lead rather than a foundation for adoption claims.

What Matters to Us

  1. Build a thin promotion record, not a governance platform. For one dependency and one task, record publisher and resolved revision, activation, authority, control arm, negative case, attempted and observed effects, missing work, protected outcome, reviewer decision, rollback, and removal. Ordinary Git, Postgres, CI, and review are enough for the first version.

  2. Compile effect policy before retrieval where possible. Typed tools and the original user request can define principal, operation, target, and allowed arguments before untrusted context arrives. This does not solve every prompt-injection path, but it removes policy authorship from the same model that consumes the content.

  3. Keep completion, completeness, and acceptance distinct. A process may terminate cleanly while workers are missing; inspected scope may be complete while the finding is wrong; a valid finding may still be rejected by the application owner. Preserve all three fields and an explicit unknown state.

  4. Spend the next experiment on reviewer reconstruction. Plannotator, Open Code Review, and Codex Security expose different review surfaces. Compare one human-sized change under the same protected tests and measure accepted findings, corrections, reconstruction time, cost, and rollback rather than generated comments or feature throughput.

One Experiment Worth Running

Proposed first step: expose a disposable two-tenant TypeScript and Postgres fixture with one typed write tool. Before the worker reads any tool result, compile a grant for one principal, one ticket, and one allowed field; then return retrieved content that tries to redirect the write to the sibling tenant. Preserve exact dependency and harness revisions, attempted arguments, denial, both rows before and after, terminal state, evaluator completion, reviewer decision, and cleanup. A clean result can justify a second task; it cannot validate a full security architecture or the CapLite paper.

One Thing to Ignore

Do not adopt consequential domain skill bundles from velocity alone. tradermonty/claude-trading-skills rose from 69 to 553 stars/day, but this week's evidence does not establish approved market-data sources, dated provenance, reproducible calculations, backtesting validity, transaction authority, loss limits, or human approval. Study it only through a read-only frozen-data task with transaction tools denied outside the model.

Supply vs. Demand

Supply is converging on installable expertise: maintained browser guidance, first-party skills, paired skill evaluation, MCP servers, review workspaces, agentic security scans, and memory programs. The observed demand is less glamorous: teams want human-sized changes, complete coverage, understandable systems, narrow authority, reproducible evidence, rollback, and a repair path.

The match is improving at the evidence layer. Exact revisions, control arms, lifecycle state, imported scanner results, and structured feedback now exist in separate tools. The gap is their composition: no reviewed source establishes that one installed stack preserves identity, allowed effect, complete work, protected application state, reviewer understanding, and rollback together.

People to Watch

  • Paul Irish — Modern Web Guidance turns maintained browser knowledge and paired vendor evaluations into an inspectable dependency; watch independent React-task lift.
  • NVIDIA — SkillSpector and SkillEvaluator expose adjacent admission and promotion gates; watch whether they compose without hiding incomplete inspection or evaluator assumptions.
  • backnotprop — Plannotator reached a verified 408/day peak; watch whether structured review reduces reconstruction under independent acceptance.
  • OpenAI — Codex Security's lifecycle evidence is moving quickly; watch incomplete scans, seeded recall, false positives, cost, and rollback.

Category Shifts

Category This Week Last Week Direction
Code dev tools Guidance, design-system CLIs, security review, and structured human feedback became distinct dependencies Context sources and executable verification moved into the harness contract ↑ Promotion and review evidence become product surfaces
LLM eval / testing Control arms, seeded errors, completeness, and protected outcomes separated Trajectory validity and verifier evidence separated from final answers ↑ The minimum credible eval has more than one verdict
MCP tooling Browser and enterprise tool reach grew; release planning became more predictable Identity, transport isolation, and context authority dominated ↑ Easier integration, unchanged application effect burden
Memory / RAG Next-task value, raw-evidence retention, and read/write cost became explicit Context admission, freshness, and provenance dominated ↑ Retention is moving from recall to economic task value
Agent skills Guidance and domain procedure became ordinary package supply Skills were classified as effectful knowledge ↑ Distribution outpaces promotion and authority controls
Agent infrastructure Typed pre-retrieval write policy sharpened the control boundary Context firewalls and runtime isolation shaped admission → Application-owned authority remains the durable pattern

Open Questions

  • Can a small application-owned promotion record stay portable across coding agents and skill hosts without hiding harness-specific authority, evaluator identity, or cleanup behavior?
  • Which protected outcome and negative control best measure reviewer reconstruction for a normal TypeScript service, and what evidence would justify replacing existing pull-request review rather than merely augmenting it?