Agentic Velocity Without Quality Loss

Batch edits, fast-apply models, parallel search, and the skills ecosystem — the 2026 SOTA for making coding agents faster while making them more reliable, and how each layer is instrumented in the console.

Executive summary

The first paper in this series (Working with Large Codebases) covered how agents find code. This one covers how they change it — and how fast the whole loop runs. The 2026 finding that anchors everything: the biggest speed optimizations are also reliability optimizations. Atomic batch edits eliminate half-applied refactors, not just round-trips. Fast-apply models merge edits more accurately than frontier models rewrite files. Parallel search subagents keep the coding model's context clean, which measurably improves output quality. Speed and quality are not a trade-off at the current frontier; they come from the same architectural moves.

Those moves decompose into five velocity layers: atomic batch editing, fast-apply merging, deterministic codemods, parallel search with subagent isolation, and procedural knowledge (skills). Ozzy Dev ships layer four already; the first three land as the editing-category catalog entries below, and the KPI schema tracks all five in the console.

The five velocity layers

Atomic batch editing

Problem: One edit per tool call means N round-trips, partial-failure states, and stale-context retry loops.

SOTA: Transactional multi-file patch tools: all-or-nothing writes, dry-run preview, fuzzy anchoring that survives context drift, structured failure diagnostics.

Our pick: weave-patch-mcp

Fast-apply merging

Problem: Full-file rewrites by frontier models are slow (~80 tok/s) and expensive; string-replace edits fail 4–16% of the time and trigger 2–3.5× retry turns.

SOTA: Small (3–8B) purpose-trained merge models at 10k+ tok/s: the planner emits lazy diffs, the specialist merges them at 98–100% accuracy.

Our pick: Morph Fast Apply (morphmcp) — elected fast-apply default of the ozzydev-write router (ADR-008); Relace is the one-flip alternate

Deterministic codemods

Problem: Mechanical sweeps (rename an API across 50 files) hand-authored per-file by the LLM waste tokens and introduce per-file variance.

SOTA: AST-level structural rewrite: the agent authors one rule, a deterministic engine applies it everywhere, preview-gated.

Our pick: ast-grep-mcp

Parallel search + subagent isolation

Problem: Agents spend ~60% of real-world turns on search; sequential tool calls compound latency; search debris pollutes the coding context (30%+ quality degradation).

SOTA: RL-trained search subagents with 4–12 parallel tool calls per turn, strict context isolation, minimal-span report-back.

Our pick: Shipped: ozzydev-search (ADR-007) fronts the memory-tool portfolio; waves fan out via nexartis-parallel-waves-agent-harness (see Working with Large Codebases).

Procedural knowledge (skills)

Problem: Agents re-derive workflows every session; prompts are not portable or versionable.

SOTA: The Agent Skills open standard (SKILL.md, Dec 2025) — progressive disclosure, 40+ adopting tools, marketplaces at skills.sh / SkillsMP.

Our pick: Curated .kilo/skills/ set; console skill registry planned

The three we install (v0.1)

Selection criteria, in order: does it eliminate a failure class (not just shave latency); does it overlap with something already running; can the console gate and measure it; what is the blast radius when it misbehaves. The per-task routing rubric that decides which tool a given change goes to lives at Write Strategies for Coding Agents and is enforced in code by ozzydev-write (ADR-008, currently write-router@0.0.4: splice-first preflight → Morph fast-apply on miss) — this section is the category-level rationale, that page + ADR are the operational routing table.

weave-patch-mcp — atomic batch editing

Single patch__exec tool covering view/read/map/create/write/update/move/delete across N files in one atomic call. Two-phase commit with shadow files — any failure rolls back everything. Three-phase matching (exact → whitespace-normalized → fuzzy ≥85%) survives context drift; failures return the top-3 closest matches with similarity scores so the agent self-corrects without re-reading the file. Accepts native *** Begin Patch blocks unchanged. dry_run previews the whole batch.

Risk & mitigation: Young project (0.0.x); trust-score services rank it low on maturity. Mitigation: workspace-scoped, dry-run-first convention, and git diff verification after every batch — same discipline we apply to Serena edits.

github.com/tuanhung303/weave-patch-mcp

Morph Fast Apply — fast-apply merging

A 7B merge model at 10,500 tok/s with 98–100% merge success when paired with frontier planners, vs 84–96% for search-and-replace. The planner emits only changed lines with “… existing code …” markers; Morph merges server-side. Cuts edit tokens 40–60% and eliminates drift-induced retry loops. 262K context handles our largest generated files. We run it in edit-only mode (ALL_TOOLS=false) — search stays with our local memory stack.

Risk & mitigation: Hosted API: code leaves the machine, per-token cost ($0.80–0.90/M input). Key lives in the console Secrets panel (ADR-006), never in tracked files; the server ships disabled until a key is configured. Fallback path is always the native edit tools.

docs.morphllm.com/guides/mcp

ast-grep-mcp — deterministic codemods

Structural search/rewrite over tree-sitter ASTs — patterns look like the code they match. One rule sweeps hundreds of files deterministically: zero per-file LLM variance, zero merge risk. Rewrites are hard-gated: rewrite requires an explicit apply flag; apply:false previews, apply:true mutates. Workspace-relative path validation rejects escapes and symlinks out of the workspace; stdio only.

Risk & mitigation: Rule authoring has a learning curve (the agent must read ast-grep pattern docs); misauthored rules match too broadly. Mitigation: preview-first is enforced by the tool contract itself.

github.com/spiritledsoftware/ast-grep-mcp

The skills ecosystem

Skills are the procedural-knowledge layer: portable, version-controlled workflow folders that load on demand. The standard moved faster than any prior cross-vendor agreement in this space, and it is now the distribution channel for exactly the kind of editing discipline this paper prescribes (dry-run-first conventions, validate gates, codemod recipes).

• Anthropic published the Agent Skills spec 2025-12-18; Microsoft (VS Code) and OpenAI (Codex/ChatGPT) adopted within 48 hours; 40+ tools by mid-2026 — Cursor, Gemini CLI, Copilot, OpenCode, Goose, JetBrains Junie, Roo Code, Kilo.
• Marketplaces: skills.sh (Vercel, CLI installer: npx skills add <author/skill>), SkillsMP (160k+ indexed from GitHub), VoltAgent/awesome-agent-skills (curated ~300). Official vendor skills exist from dbt Labs, Supabase, Vercel.
• Progressive disclosure is the contract: ~100 tokens per installed skill at startup (name + description), full SKILL.md (<5k tokens recommended) loads only on activation, bundled scripts/references load only when referenced.
• Security is the open wound: Snyk’s ToxicSkills audit found issues in 13.4% of scanned skills and dozens of confirmed malicious payloads. No signing, no verified publishers yet. Rule: review SKILL.md before install; prefer project-scoped installs; treat marketplace skills as untrusted code.
• Authoring SOTA: gotcha lists beat generic advice; plan-validate-execute loops for batch/destructive operations; bundle deterministic scripts when the agent keeps reinventing logic; skills for portable procedure, AGENTS.md for repo context (Vercel’s evals: AGENTS.md wins for project-specific tasks).

We already run a curated set in .kilo/skills/ (the taste-skill family). The console gets a skill registry mirroring the MCP catalog: installed skills, source, last-reviewed date, activation stats, and the same enable/disable gating — because the ToxicSkills numbers make unreviewed marketplace installs indefensible for a platform product.

KPIs — how each layer is measured

The canonical recording schema and the category × KPI × experiment-mode matrix live at A Common Experimental Framework for Agent Tooling. The list below is the velocity-layer instantiation of that schema: which counters and outcome metrics each of the five layers reports. Baseline traces are captured before enabling each tool so deltas are honest.

• Batch editing (weave): edit tool calls per completed task; files touched per call; batch success rate; rollback count; partial-state incidents (target: zero by construction); tokens spent on edit round-trips
• Fast apply (Morph): merge success rate (target ≥98%); retry turns per edit vs native baseline; apply latency per file; $ per merged edit; % of edits routed to fast apply vs native tools
• Codemods (ast-grep): files rewritten per rule application; preview→apply conversion rate; post-apply validate-gate pass rate; rule authoring time vs equivalent manual edit trace
• Search (existing stack): % of session turns spent searching; parallel tool calls per turn; turns-to-first-relevant-file; context tokens consumed before first edit
• Skills: activation rate per skill; task success delta with skill active vs not; skill context overhead (startup tokens); stale-skill flags (last-verified date)

The wider landscape

Evaluated and tracked, not (yet) adopted. Any of these could displace a current pick.

• mcp-multi-edit — atomic batch editing. multi_edit + multi_edit_files: batched find-and-replace with cross-file rollback, dry-run, backups. Benchmarks: −94% tool calls, −71% tokens vs one-edit-per-call. Simpler surface than weave; lost the pick because weave also covers create/move/delete and accepts apply_patch blocks.
• patchloom — config-safe batch editing. Single Rust binary; parser-backed (CST) edits to JSON/YAML/TOML by selector — preserves comments, never emits invalid syntax; heading-aware markdown ops; batch/tx with atomic rollback. Its own benchmarks show native tools win some raw-latency races — the value is correctness on config files. Strong candidate for a follow-up install when config sweeps become frequent.
• Zenith-MCP — AST refactor suite. refactor_batch: impact-graph query → symbol loading with outlier detection → atomic multi-file apply with SQLite version snapshots and point-in-time rollback. The most ambitious editing MCP we found; overlaps heavily with Serena + codesearch, so adopting it would fork our symbol-graph story.
• patchitRIGHT — transactional diff patching. batch_patch_files with full rollback, AST-scoped search-and-replace, dry-run with cached run IDs. Solid; weave covers the same ground with a broader op set.
• Relace Apply 3 — fast-apply merging. The other production fast-apply: 10k tok/s via speculative decoding, 256k context, universal merger (lazy + udiff + string-replace in one). Training recipe open-sourced. Direct Morph alternative if pricing or quality shifts.
• Relace Fast Agentic Search (FAS) — search subagent. RL-trained search subagent: 4–12 parallel tool calls/turn, 4× search latency reduction at Claude-4.5-Sonnet-level accuracy. Available via OpenAI-compatible endpoint. Candidate subagent engine for Parallel Waves research jobs.
• Morph WarpGrep — search subagent. 0.73 F1 in 3.8 steps vs Claude Haiku 0.72 in 12.4 steps; −15.6% cost, −28% latency per task on SWE-Bench Pro. Ships inside the same morphmcp server we install (we keep it disabled initially to benchmark against codesearch/chunkhound first).
• Codemod MCP — codemod authoring. Agent authors a tested JSSG/ast-grep codemod package, then runs it deterministically. Heavier workflow than ast-grep-mcp; right tool when a migration needs versioned, reusable transforms (SDK breaking changes).
• PASTE — speculative tool execution — experimental (serving layer). Predicts likely next tool calls from recurring control-flow patterns and executes them during LLM generation: −48.5% task completion time, 1.8× tool throughput. Not productized; watch for harness-level adoption.

Open questions

• Search subagent engine: the memory stack (fronted by ozzydev-search) vs an RL-trained specialist (FAS / WarpGrep) as the Parallel Waves research-job engine. The KPI framework above gives the comparison data; WarpGrep ships disabled inside morphmcp ready for an A/B.
• Editing-tool routing. Resolved in code: ozzydev-write (ADR-008) carries the splice-first preflight → Morph fast-apply routing; the human-readable rubric lives at Write Strategies for Coding Agents. Open sub-question: whether the AGENTS.md summary of that rubric is still worth carrying now that the router enforces it.
• Speculative tool execution (PASTE-style) is a serving-layer change that cannot be adopted from userland — track OpenCode/harness support.
• Skill provenance: when the Agentic AI Foundation ships verified publishers, the console skill registry should surface provenance the way package managers surface signatures.

Field notes — measured dispatch patterns

Two sprints of orchestrator/subagent runs across a 46-repo workspace produced enough data to promote a handful of patterns from folklore to conventions. Each is measured, not asserted; the numbers below reflect the reference workstation and are now codified in the workspace AGENTS.md.

• Pre-pinpointed file sets in subagent prompts — the cheapest pattern measured. When the orchestrator already knows the file set from a memory-tool query, listing the exact paths in the subagent prompt lets the subagent skip search entirely and go straight to read/edit. This eliminates the subagent's own retrieval budget, which is the single largest cost of a naive dispatch. The rule: search once at the orchestrator, hand pinpointed answers to the subagent — not homework.
• Parallel gh/git fan-out for fleet metadata. A 45-repo PR audit that took ~60 s serially runs in ~4 s with batched gh/git calls backgrounded with & and reaped with wait. A 13-PR review pack landed in 28 s. This applies to any bounded metadata sweep (branch status, PR lists, tag checks) — the operations are IO-bound and independent, so serial execution is pure waste.
• Verify the artifact, not the log line. A classified false positive survived a review cycle because a log line showed an unexpanded ${VAR} and inspection stopped there — the actual webhook payloads on disk were clean. Rule: log-derived findings must be confirmed against the actual output (payload, file, DB row) before they file an issue. Logs summarise; artifacts decide.
• Worktree audits use native tools. Index-backed tools (chunkhound, codesearch, serena) track the checked-out branch of their host worktree; auditing a different ref from a scratch worktree with them returns confidently wrong answers. Convention: native git show origin/<ref>:<path> plumbing or a read-only worktree for cross-branch inspection. Indexes are for the branch actually being edited.
• Agents never merge — a safety property that survives every velocity optimisation. The one operation whose blast radius is the whole repository stays with a human reviewer, even when CI is green. Agents prepare branches, PRs, and review packets; a human colleague approves and merges. This is not a productivity trade-off; velocity elsewhere in this paper is what makes the safety property affordable.

The through-line: velocity comes from moving work to the cheapest layer that can do it correctly. Pinpointing beats searching; parallel batches beat serial ones; artifacts beat logs; native git beats a stale index; a human reviewer beats an agent at the one operation whose blast radius is the whole repository.

Notable recent items

Patterns and warnings from the surrounding weeks that shape how the field is tracked.

• 2026-06 (public beta) — Sourcegraph Agentic Batch Changes — public beta. Cross-repo migrations orchestrated by agents; the closest external analog to our wave methodology. Worth studying for the pattern differences (Sourcegraph runs off SCIP + a hosted graph; we run off memory tools + per-repo PRs).
• 2026-06-16 — Sourcegraph MCP + a cheaper model beats a bigger model alone. Concrete evidence that retrieval quality dominates model choice at fixed cost. Reinforces our "tooling health outranks feature work" rule and the memory-first workflow.
• 2026-06-25 — Cursor — "Reward hacking is swamping model intelligence gains". Warning shot on RLHF-only scaling: gains from bigger models are being eaten by reward-hacking artefacts. Argues for our approach — deterministic tools + typed contracts + validate gates around the model — over trusting the next model bump.
• 2026-06 (Simon Willison thread) — "CLI beats MCP for coding agents". Argument that agent-facing CLIs (gh, git, wrangler, well-scoped shell) beat wrapper MCPs on latency, parallelism, and legibility. Directly informs our routing table: CLI first, MCP where it earns its slot (memory tools, hosted docs, fast-apply).
• 2026-07-12 — Harness-level A/B: KYM bandit workstream launched. Clones of the same production agent set — same KYM agent cards, same memory stack, same skills — run against varying harnesses (kilo, claude-code, opencode, aider, augment auggie). Receipts and votes become the reward signal; the bandit picks the winning harness per task class. Connects directly to memory-tooling D10 (single library + engine adapters as the parallel-waves architecture that makes this A/B possible).
• 2026-07-12 — Parallel-waves repo renamed + D10 decided. nexartis-opencode-parallel-waves → nexartis-parallel-waves-agent-harness. Memory-tooling D10 landed on option (a): single library + engine adapters, Terminal-Bench BaseAgent shape for base.py, mini-swe-agent as the control arm, two-tier adapter model (native per-engine + generic ACP). v1 retires after claude-code parity is confirmed on v2. Methodology detail — including the tier-1 harness table — lives on the new /research/harness-bandit-experiments page.

Voices to follow

The signals we track to catch shifts before they land in production tools. Tiered by cadence: T1 weekly, T2 monthly, T3 situational.

T1 — weekly

• Relace Blog — Fast apply, fast agentic search, training recipes for small specialised coding models.
• Morph Blog — Fast Apply, WarpGrep, codegen inference research; infrastructure-model thesis for coding agents.
• Anthropic Engineering — MCP protocol, Claude Code changelog, agent skill spec updates.
• Cloudflare Workers / Agents team — Workers AI, Agents SDK, Durable Objects for stateful agents — the substrate we build on.
• Simon Willison — Highest-signal daily tooling coverage; tracked skills spec pre-announcement; regular MCP/CLI takes.
• ChunkHound releases (Ofri Wolfus) — Direct upstream for our semantic layer; compaction PR #339, phased-indexing #340.
• Serena releases (oraios) — Direct upstream for our symbol layer; transport/backend updates land here.
• Sourcegraph + Amp (incl. Thorsten Ball, Register Spill) — SCIP cross-repo navigation, Agentic Batch Changes, Amp harness engineering notes.
• Armin Ronacher — Pragmatic takes on agent tooling, harness design, and Python ergonomics for agents.
• Geoffrey Litt — End-user programming, small tools, agent UX experiments — where taste meets tooling.
• Cursor engineering — Secure codebase indexing, Merkle/simhash freshness, harness-level fast-apply integration.
• Voyage AI — Our embedding + rerank vendor; voyage-context-4 (2026-06-29) reshapes chunking assumptions.
• Addy Osmani — agent-skills — Authoring patterns for the skills ecosystem; gotcha lists, plan-validate-execute loops.
• Anthropic harness posts (Sean Young, Neal Rajasekaran) — First-party harness-engineering writeups: Claude Code architecture, tool contract choices, edit-format receipts.
• OpenAI harness engineering — Codex CLI + apply_patch V4A design notes; the reference for the V4A patch format other tools track.
• Mitchell Hashimoto — Pragmatic systems-level takes on agent tooling and terminal UX; independent voice with taste and reach.
• OpenHands / All-Hands AI — Open-source agent harness + alternative-agents index; Terminal-Bench numbers land here.
• Terminal-Bench / Laude Institute — BaseAgent shape + the terminal-agent leaderboard; the benchmark our nexartis-parallel-waves-agent-harness engine adapters aim at.
• Harrison Chase — deep agents — LangChain-adjacent, but the deep-agents thread is a durable frame for planner/subagent decomposition.
• Dex Horthy — 12-factor agents — 12-factor pattern-language for production agent systems; the closest thing to an operational rubric for the harness layer.
• Ramp Labs — Applied AI-agent writeups from a scaled production shop; concrete latency/cost/quality trade-offs.
• xAI / SpaceXAI (news + docs) — Post-reorg (2026-05: xAI dissolved into SpaceX as the "SpaceXAI" division) there is still no public SpaceX AI-engineering blog; x.ai/news and docs.x.ai remain the primary channels for Grok model releases, API surfaces, and Grok Build harness updates. Track for grok-4.5 + grok-build-0.1 harness-bandit arms.

T2 — monthly

• Cognition — SWE-grep / Fast Context; the ~60%-of-turns-on-search measurement anchor.
• Peter Steinberger — Working notes on running frontier coding agents in production; sharp practical detail.
• Geoffrey Huntley — Agent operations at scale, autonomous coding loops, hard-won field lessons.
• Letta (Packer / Wooders) — MemGPT lineage; sleep-time consolidation; long-lived agent memory research.
• Hamel Husain + Shreya Shankar (evals) — The evals canon — how to actually measure whether an agent got better.
• ast-grep — Structural search/rewrite; active releases; the deterministic-codemod substrate.
• Context7 / Upstash — Hosted docs MCP + serverless data; releases affect our reference-docs paradigm directly.
• Qodo — Qodo-Embed and code-review agents; open-source challenger to Voyage on code retrieval.
• sst/opencode releases — Our harness upstream; transport, tool contract, and skill support land here.
• Jesse Vincent — Superpowers — Skill-authoring craft; concrete patterns for portable procedural knowledge.
• Agent Skills workshop / SkillsBench — Community authoring conventions + a benchmark that will decide which skills survive.
• xai-sdk-python releases — xAI Python SDK release stream; the ground-truth surface for grok-* API changes we consume in the Grok Build adapter. No public SpaceX AI-eng blog exists post-reorg — this is the closest primary source.
• OpenRouter x-ai model cards — Third-party surface for grok-* model cards, pricing, and context-window changes; useful when Grok Build harness numbers need to be normalised across providers.

T3 — situational

• Aider — Repomap (tree-sitter + PageRank) and edit-format research; check on major releases.
• LangChain / LlamaIndex — Not our stack, but the leading indicator for retrieval + agent-orchestration patterns.
• Individual Cloudflare authors — Kenton Varda, Sunil Pai, Ashcon Partovi — deep dives on the Workers primitives we ride.
• AI Engineer (AIE) talks — Conference talks — dip in when a specific speaker overlaps our roadmap.

How we keep this paper current

Living document. When a tool is enabled, benchmarked, or swapped, this page updates in place with the measured numbers and a version bump. The KPI section is now live against the nexartis-parallel-waves-agent-harness telemetry pipe; deltas land here as waves report.